TcDerivUtils

Documentation

type DerivM = ReaderT DerivEnv TcRn

To avoid having to manually plumb everything in DerivEnv throughout various functions in TcDeriv and TcDerivInfer, we use DerivM, which is a simple reader around TcRn.

data DerivEnv

Contains all of the information known about a derived instance when determining what its EarlyDerivSpec should be.

Constructors

DerivEnv

Fields

• denv_overlap_mode :: Maybe OverlapMode

  Is this an overlapping instance?

• denv_tvs :: [TyVar]

  Universally quantified type variables in the instance

• denv_cls :: Class

  Class for which we need to derive an instance

• denv_cls_tys :: [Type]

  Other arguments to the class except the last

• denv_tc :: TyCon

  Type constructor for which the instance is requested (last arguments to the type class)

• denv_tc_args :: [Type]

  Arguments to the type constructor

• denv_rep_tc :: TyCon

  The representation tycon for denv_tc (for data family instances)

• denv_rep_tc_args :: [Type]

  The representation types for denv_tc_args (for data family instances)

• denv_mtheta :: DerivContext

  Just the context of the instance, for standalone deriving. Nothing for deriving clauses.

• denv_strat :: Maybe DerivStrategy

  Just if user requests a particular deriving strategy. Otherwise, Nothing.

Instances

Outputable DerivEnv

Defined in TcDerivUtils

Methods

ppr :: DerivEnv -> SDoc

pprPrec :: Rational -> DerivEnv -> SDoc

data DerivSpec theta

Constructors

DS

Fields

• ds_loc :: SrcSpan
• ds_name :: Name
• ds_tvs :: [TyVar]
• ds_theta :: theta
• ds_cls :: Class
• ds_tys :: [Type]
• ds_tc :: TyCon
• ds_overlap :: Maybe OverlapMode
• ds_mechanism :: DerivSpecMechanism

Instances

Outputable theta => Outputable (DerivSpec theta)

Defined in TcDerivUtils

Methods

ppr :: DerivSpec theta -> SDoc

pprPrec :: Rational -> DerivSpec theta -> SDoc

pprDerivSpec :: Outputable theta => DerivSpec theta -> SDoc

data DerivSpecMechanism

Constructors

DerivSpecStock (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))

DerivSpecNewtype Type

DerivSpecAnyClass

Instances

Outputable DerivSpecMechanism

Defined in TcDerivUtils

Methods

ppr :: DerivSpecMechanism -> SDoc

pprPrec :: Rational -> DerivSpecMechanism -> SDoc

isDerivSpecStock :: DerivSpecMechanism -> Bool

isDerivSpecNewtype :: DerivSpecMechanism -> Bool

isDerivSpecAnyClass :: DerivSpecMechanism -> Bool

type DerivContext = Maybe ThetaType

data DerivStatus

Constructors

CanDerive

DerivableClassError SDoc

DerivableViaInstance

NonDerivableClass SDoc

data PredOrigin

A PredType annotated with the origin of the constraint CtOrigin, and whether or the constraint deals in types or kinds.

Constructors

PredOrigin PredType CtOrigin TypeOrKind

Instances

Outputable PredOrigin

Defined in TcDerivUtils

Methods

ppr :: PredOrigin -> SDoc

pprPrec :: Rational -> PredOrigin -> SDoc

data ThetaOrigin

A list of wanted PredOrigin constraints (to_wanted_origins) to simplify when inferring a derived instance's context. These are used in all deriving strategies, but in the particular case of DeriveAnyClass, we need extra information. In particular, we need:

• to_anyclass_skols, the list of type variables bound by a class method's regular type signature, which should be rigid.
• to_anyclass_metas, the list of type variables bound by a class method's default type signature. These can be unified as necessary.
• to_anyclass_givens, the list of constraints from a class method's regular type signature, which can be used to help solve constraints in the to_wanted_origins.

(Note that to_wanted_origins will likely contain type variables from the derived type class or data type, neither of which will appear in to_anyclass_skols or to_anyclass_metas.)

For all other deriving strategies, it is always the case that to_anyclass_skols, to_anyclass_metas, and to_anyclass_givens are empty.

Here is an example to illustrate this:

class Foo a where
  bar :: forall b. Ix b => a -> b -> String
  default bar :: forall y. (Show a, Ix y) => a -> y -> String
  bar x y = show x ++ show (range (y, y))

  baz :: Eq a => a -> a -> Bool
  default baz :: Ord a => a -> a -> Bool
  baz x y = compare x y == EQ

data Quux q = Quux deriving anyclass Foo

Then it would generate two ThetaOrigins, one for each method:

[ ThetaOrigin { to_anyclass_skols  = [b]
              , to_anyclass_metas  = [y]
              , to_anyclass_givens = [Ix b]
              , to_wanted_origins  = [ Show (Quux q), Ix y
                                     , (Quux q -> b -> String) ~
                                       (Quux q -> y -> String)
                                     ] }
, ThetaOrigin { to_anyclass_skols  = []
              , to_anyclass_metas  = []
              , to_anyclass_givens = [Eq (Quux q)]
              , to_wanted_origins  = [ Ord (Quux q)
                                     , (Quux q -> Quux q -> Bool) ~
                                       (Quux q -> Quux q -> Bool)
                                     ] }
]

(Note that the type variable q is bound by the data type Quux, and thus it appears in neither to_anyclass_skols nor to_anyclass_metas.)

See Note [Gathering and simplifying constraints for DeriveAnyClass] in TcDerivInfer for an explanation of how to_wanted_origins are determined in DeriveAnyClass, as well as how to_anyclass_skols, to_anyclass_metas, and to_anyclass_givens are used.

Constructors

ThetaOrigin

Fields

• to_anyclass_skols :: [TyVar]
• to_anyclass_metas :: [TyVar]
• to_anyclass_givens :: ThetaType
• to_wanted_origins :: [PredOrigin]

Instances

Outputable ThetaOrigin

Defined in TcDerivUtils

Methods

ppr :: ThetaOrigin -> SDoc

pprPrec :: Rational -> ThetaOrigin -> SDoc

mkPredOrigin :: CtOrigin -> TypeOrKind -> PredType -> PredOrigin

mkThetaOrigin :: CtOrigin -> TypeOrKind -> [TyVar] -> [TyVar] -> ThetaType -> ThetaType -> ThetaOrigin

mkThetaOriginFromPreds :: [PredOrigin] -> ThetaOrigin

substPredOrigin :: HasCallStack => TCvSubst -> PredOrigin -> PredOrigin

checkSideConditions :: DynFlags -> DerivContext -> Class -> [TcType] -> TyCon -> DerivStatus

hasStockDeriving :: Class -> Maybe (SrcSpan -> TyCon -> [Type] -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name]))

canDeriveAnyClass :: DynFlags -> Validity

std_class_via_coercible :: Class -> Bool

non_coercible_class :: Class -> Bool

newDerivClsInst :: ThetaType -> DerivSpec theta -> TcM ClsInst

extendLocalInstEnv :: [ClsInst] -> TcM a -> TcM a