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_ctxt :: DerivContext

  SupplyContext theta for standalone deriving (where theta is the context of the instance). InferContext for deriving clauses, or for standalone deriving that uses a wildcard constraint. See Note [Inferring the instance context].

• denv_strat :: Maybe (DerivStrategy GhcTc)

  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_standalone_wildcard :: Maybe SrcSpan
• 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

DerivSpecVia Type

Instances

Outputable DerivSpecMechanism

Defined in TcDerivUtils

Methods

ppr :: DerivSpecMechanism -> SDoc

pprPrec :: Rational -> DerivSpecMechanism -> SDoc

derivSpecMechanismToStrategy :: DerivSpecMechanism -> DerivStrategy GhcTc

Convert a DerivSpecMechanism to its corresponding DerivStrategy.

isDerivSpecStock :: DerivSpecMechanism -> Bool

isDerivSpecNewtype :: DerivSpecMechanism -> Bool

isDerivSpecAnyClass :: DerivSpecMechanism -> Bool

isDerivSpecVia :: DerivSpecMechanism -> Bool

data DerivContext

Whether GHC is processing a deriving clause or a standalone deriving declaration.

Constructors

InferContext (Maybe SrcSpan)

'InferContext mb_wildcard is either:

• A deriving clause (in which case mb_wildcard is Nothing).
• A standalone deriving declaration with an extra-constraints wildcard as the context (in which case mb_wildcard is Just loc, where loc is the location of the wildcard.

GHC should infer the context.

SupplyContext ThetaType

SupplyContext theta is a standalone deriving declaration, where theta is the context supplied by the user.

Instances

Outputable DerivContext

Defined in TcDerivUtils

Methods

ppr :: DerivContext -> SDoc

pprPrec :: Rational -> DerivContext -> SDoc

data OriginativeDerivStatus

Records whether a particular class can be derived by way of an originative deriving strategy (i.e., stock or anyclass).

See Note [Deriving strategies] in TcDeriv.

Constructors

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

StockClassError SDoc

CanDeriveAnyClass

NonDerivableClass SDoc

isStandaloneDeriv :: DerivM Bool

Is GHC processing a stanalone deriving declaration?

isStandaloneWildcardDeriv :: DerivM Bool

Is GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., deriving instance _ => Eq (Foo a))

mkDerivOrigin :: Bool -> CtOrigin

mkDerivOrigin wc returns StandAloneDerivOrigin if wc is True, and DerivClauseOrigin if wc is False. Useful for error-reporting.

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

checkOriginativeSideConditions :: DynFlags -> DerivContext -> Class -> [TcType] -> TyCon -> TyCon -> OriginativeDerivStatus

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