Commit 5b627813 authored by Ryan Scott's avatar Ryan Scott Committed by Marge Bot

Use InstanceSigs in GND/DerivingVia-generated code (#17899)

Aside from making the generated code easier to read when
`-ddump-deriv` is enabled, this makes the error message in `T15073`
substantially simpler (see the updated `T15073` expected stderr).

Fixes #17899.
parent 7d95260f
Pipeline #16542 failed with stages
in 372 minutes and 19 seconds
......@@ -725,9 +725,10 @@ signatures in order to kind-check. Here is an example from #14579:
The derived Eq instance for Glurp (without any kind signatures) would be:
instance Eq a => Eq (Glurp a) where
(==) :: Glurp a -> Glurp a -> Bool
(==) = coerce @(Wat2 P -> Wat2 P -> Bool)
@(Glurp a -> Glurp a -> Bool)
(==) :: Glurp a -> Glurp a -> Bool
(==)
(Where the visible type applications use types produced by typeToLHsType.)
......
......@@ -42,7 +42,6 @@ import TyCoPpr ( pprTyVars )
import GHC.Rename.Names ( extendGlobalRdrEnvRn )
import GHC.Rename.Binds
import GHC.Rename.Env
import GHC.Rename.Utils ( bindLocalNamesFV )
import GHC.Rename.Source ( addTcgDUs )
import Avail
......@@ -315,12 +314,11 @@ renameDeriv inst_infos bagBinds
, ib_pragmas = sigs
, ib_extensions = exts -- Only for type-checking
, ib_derived = sa } })
= ASSERT( null sigs )
bindLocalNamesFV tyvars $
do { (rn_binds,_, fvs) <- rnMethodBinds False (is_cls_nm inst) [] binds []
= do { (rn_binds, rn_sigs, fvs) <- rnMethodBinds False (is_cls_nm inst)
tyvars binds sigs
; let binds' = InstBindings { ib_binds = rn_binds
, ib_tyvars = tyvars
, ib_pragmas = []
, ib_pragmas = rn_sigs
, ib_extensions = exts
, ib_derived = sa }
; return (inst_info { iBinds = binds' }, fvs) }
......@@ -1846,7 +1844,7 @@ genInst :: DerivSpec theta
genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
, ds_tys = tys, ds_cls = clas, ds_loc = loc
, ds_standalone_wildcard = wildcard })
= do (meth_binds, deriv_stuff, unusedNames)
= do (meth_binds, meth_sigs, deriv_stuff, unusedNames)
<- set_span_and_ctxt $
genDerivStuff mechanism loc clas tys tvs
let mk_inst_info theta = set_span_and_ctxt $ do
......@@ -1858,7 +1856,7 @@ genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
, iBinds = InstBindings
{ ib_binds = meth_binds
, ib_tyvars = map Var.varName tvs
, ib_pragmas = []
, ib_pragmas = meth_sigs
, ib_extensions = extensions
, ib_derived = True } }
return (mk_inst_info, deriv_stuff, unusedNames)
......@@ -1866,9 +1864,14 @@ genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
extensions :: [LangExt.Extension]
extensions
| isDerivSpecNewtype mechanism || isDerivSpecVia mechanism
-- Both these flags are needed for higher-rank uses of coerce
-- See Note [Newtype-deriving instances] in TcGenDeriv
= [LangExt.ImpredicativeTypes, LangExt.RankNTypes]
= [
-- Both these flags are needed for higher-rank uses of coerce...
LangExt.ImpredicativeTypes, LangExt.RankNTypes
-- ...and this flag is needed to support the instance signatures
-- that bring type variables into scope.
-- See Note [Newtype-deriving instances] in TcGenDeriv
, LangExt.InstanceSigs
]
| otherwise
= []
......@@ -2035,7 +2038,7 @@ derivingThingFailWith newtype_deriving msg = do
genDerivStuff :: DerivSpecMechanism -> SrcSpan -> Class
-> [Type] -> [TyVar]
-> TcM (LHsBinds GhcPs, BagDerivStuff, [Name])
-> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name])
genDerivStuff mechanism loc clas inst_tys tyvars
= case mechanism of
-- See Note [Bindings for Generalised Newtype Deriving]
......@@ -2045,7 +2048,8 @@ genDerivStuff mechanism loc clas inst_tys tyvars
-- Try a stock deriver
DerivSpecStock { dsm_stock_dit = DerivInstTys{dit_rep_tc = rep_tc}
, dsm_stock_gen_fn = gen_fn }
-> gen_fn loc rep_tc inst_tys
-> do (binds, faminsts, field_names) <- gen_fn loc rep_tc inst_tys
pure (binds, [], faminsts, field_names)
-- Try DeriveAnyClass
DerivSpecAnyClass -> do
......@@ -2059,7 +2063,7 @@ genDerivStuff mechanism loc clas inst_tys tyvars
, ppr "genDerivStuff: bad derived class" <+> ppr clas )
mapM (tcATDefault loc mini_subst emptyNameSet)
(classATItems clas)
return ( emptyBag -- No method bindings are needed...
return ( emptyBag, [] -- No method bindings are needed...
, listToBag (map DerivFamInst (concat tyfam_insts))
-- ...but we may need to generate binding for associated type
-- family default instances.
......@@ -2071,8 +2075,8 @@ genDerivStuff mechanism loc clas inst_tys tyvars
-> gen_newtype_or_via via_ty
where
gen_newtype_or_via ty = do
(binds, faminsts) <- gen_Newtype_binds loc clas tyvars inst_tys ty
return (binds, faminsts, [])
(binds, sigs, faminsts) <- gen_Newtype_binds loc clas tyvars inst_tys ty
return (binds, sigs, faminsts, [])
{-
Note [Bindings for Generalised Newtype Deriving]
......
......@@ -952,7 +952,8 @@ pprInstInfoDetails info
= hang (pprInstanceHdr (iSpec info) <+> text "where")
2 (details (iBinds info))
where
details (InstBindings { ib_binds = b }) = pprLHsBinds b
details (InstBindings { ib_pragmas = p, ib_binds = b }) =
pprDeclList (pprLHsBindsForUser b p)
simpleInstInfoClsTy :: InstInfo a -> (Class, Type)
simpleInstInfoClsTy info = case instanceHead (iSpec info) of
......
......@@ -1610,9 +1610,10 @@ coercing from. So from, say,
newtype T x = MkT <rep-ty>
instance C a <rep-ty> => C a (T x) where
op = coerce @ (a -> [<rep-ty>] -> c -> Int)
@ (a -> [T x] -> c -> Int)
op :: forall c. a -> [T x] -> c -> Int
op :: forall c. a -> [T x] -> c -> Int
op = coerce @(a -> [<rep-ty>] -> c -> Int)
@(a -> [T x] -> c -> Int)
op
In addition to the type applications, we also have an explicit
type signature on the entire RHS. This brings the method-bound variable
......@@ -1632,16 +1633,17 @@ a polytype. E.g.
class C a where op :: a -> forall b. b -> b
newtype T x = MkT <rep-ty>
instance C <rep-ty> => C (T x) where
op = coerce @ (<rep-ty> -> forall b. b -> b)
@ (T x -> forall b. b -> b)
op :: T x -> forall b. b -> b
op :: T x -> forall b. b -> b
op = coerce @(<rep-ty> -> forall b. b -> b)
@(T x -> forall b. b -> b)
op
The use of type applications is crucial here. If we had tried using only
explicit type signatures, like so:
instance C <rep-ty> => C (T x) where
op :: T x -> forall b. b -> b
op = coerce (op :: <rep-ty> -> forall b. b -> b)
:: T x -> forall b. b -> b
Then GHC will attempt to deeply skolemize the two type signatures, which will
wreak havoc with the Coercible solver. Therefore, we instead use type
......@@ -1721,23 +1723,26 @@ See Note [Instances in no-evidence implications] in TcInteract.
But this isn't the death knell for combining QuantifiedConstraints with GND.
On the contrary, if we generate GND bindings in a slightly different way, then
we can avoid this situation altogether. Instead of applying `coerce` to two
polymorphic types, we instead let an explicit type signature do the polymorphic
polymorphic types, we instead let an instance signature do the polymorphic
instantiation, and omit the `forall`s in the type applications.
More concretely, we generate the following code instead:
instance (C m, forall p q. Coercible p q => Coercible (m p) (m q)) =>
C (T m) where
join :: forall a. T m (T m a) -> T m a
join = coerce @( m (m a) -> m a)
@(T m (T m a) -> T m a)
join :: forall a. T m (T m a) -> T m a
join
Now the visible type arguments are both monotypes, so we need do any of this
funny quantified constraint instantiation business.
Now the visible type arguments are both monotypes, so we don't need any of this
funny quantified constraint instantiation business. While this particular
example no longer uses impredicative instantiation, we still need to enable
ImpredicativeTypes to typecheck GND-generated code for class methods with
higher-rank types. See Note [Newtype-deriving instances].
You might think that that second @(T m (T m a) -> T m a) argument is redundant
in the presence of the explicit `:: forall a. T m (T m a) -> T m a` type
signature, but in fact leaving it off will break this example (from the
T15290d test case):
in the presence of the instance signature, but in fact leaving it off will
break this example (from the T15290d test case):
class C a where
c :: Int -> forall b. b -> a
......@@ -1745,14 +1750,15 @@ T15290d test case):
instance C Int
instance C Age where
c :: Int -> forall b. b -> Age
c = coerce @(Int -> forall b. b -> Int)
c :: Int -> forall b. b -> Age
c
That is because the explicit type signature deeply skolemizes the forall-bound
That is because the instance signature deeply skolemizes the forall-bound
`b`, which wreaks havoc with the `Coercible` solver. An additional visible type
argument of @(Int -> forall b. b -> Age) is enough to prevent this.
Be aware that the use of an explicit type signature doesn't /solve/ this
Be aware that the use of an instance signature doesn't /solve/ this
problem; it just makes it less likely to occur. For example, if a class has
a truly higher-rank type like so:
......@@ -1775,8 +1781,8 @@ ambiguous type variables. As one example, consider the following example
A naïve attempt and generating a C T instance would be:
instance C T where
f :: String
f = coerce @String @String f
:: String
This isn't going to typecheck, however, since GHC doesn't know what to
instantiate the type variable `a` with in the call to `f` in the method body.
......@@ -1784,8 +1790,8 @@ instantiate the type variable `a` with in the call to `f` in the method body.
ambiguity here, we explicitly instantiate `a` like so:
instance C T where
f :: String
f = coerce @String @String (f @())
:: String
All better now.
-}
......@@ -1797,32 +1803,58 @@ gen_Newtype_binds :: SrcSpan
-- newtype itself)
-> [Type] -- instance head parameters (incl. newtype)
-> Type -- the representation type
-> TcM (LHsBinds GhcPs, BagDerivStuff)
-> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff)
-- See Note [Newtype-deriving instances]
gen_Newtype_binds loc cls inst_tvs inst_tys rhs_ty
= do let ats = classATs cls
(binds, sigs) = mapAndUnzip mk_bind_and_sig (classMethods cls)
atf_insts <- ASSERT( all (not . isDataFamilyTyCon) ats )
mapM mk_atf_inst ats
return ( listToBag $ map mk_bind (classMethods cls)
return ( listToBag binds
, sigs
, listToBag $ map DerivFamInst atf_insts )
where
mk_bind :: Id -> LHsBind GhcPs
mk_bind meth_id
= mkRdrFunBind (L loc meth_RDR) [mkSimpleMatch
(mkPrefixFunRhs (L loc meth_RDR))
[] rhs_expr]
-- For each class method, generate its derived binding and instance
-- signature. Using the first example from
-- Note [Newtype-deriving instances]:
--
-- class C a b where
-- op :: forall c. a -> [b] -> c -> Int
--
-- newtype T x = MkT <rep-ty>
--
-- Then we would generate <derived-op-impl> below:
--
-- instance C a <rep-ty> => C a (T x) where
-- <derived-op-impl>
mk_bind_and_sig :: Id -> (LHsBind GhcPs, LSig GhcPs)
mk_bind_and_sig meth_id
= ( -- The derived binding, e.g.,
--
-- op = coerce @(a -> [<rep-ty>] -> c -> Int)
-- @(a -> [T x] -> c -> Int)
-- op
mkRdrFunBind loc_meth_RDR [mkSimpleMatch
(mkPrefixFunRhs loc_meth_RDR)
[] rhs_expr]
, -- The derived instance signature, e.g.,
--
-- op :: forall c. a -> [T x] -> c -> Int
L loc $ ClassOpSig noExtField False [loc_meth_RDR]
$ mkLHsSigType $ typeToLHsType to_ty
)
where
Pair from_ty to_ty = mkCoerceClassMethEqn cls inst_tvs inst_tys rhs_ty meth_id
(_, _, from_tau) = tcSplitSigmaTy from_ty
(_, _, to_tau) = tcSplitSigmaTy to_ty
meth_RDR = getRdrName meth_id
loc_meth_RDR = L loc meth_RDR
rhs_expr = nlHsVar (getRdrName coerceId)
`nlHsAppType` from_tau
`nlHsAppType` to_tau
`nlHsApp` meth_app
`nlExprWithTySig` to_ty
-- The class method, applied to all of the class instance types
-- (including the representation type) to avoid potential ambiguity.
......
......@@ -4,23 +4,27 @@ Derived class instances:
instance (GHC.Base.Applicative f, GHC.Base.Applicative g,
GHC.Base.Semigroup a) =>
GHC.Base.Semigroup (T14578.Wat f g a) where
(GHC.Base.<>) ::
T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a
GHC.Base.sconcat ::
GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a
GHC.Base.stimes ::
forall (b :: TYPE GHC.Types.LiftedRep).
GHC.Real.Integral b => b -> T14578.Wat f g a -> T14578.Wat f g a
(GHC.Base.<>)
= GHC.Prim.coerce
@(T14578.App (Data.Functor.Compose.Compose f g) a
-> T14578.App (Data.Functor.Compose.Compose f g) a
-> T14578.App (Data.Functor.Compose.Compose f g) a)
@(T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a)
((GHC.Base.<>)
@(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a
((GHC.Base.<>) @(T14578.App (Data.Functor.Compose.Compose f g) a))
GHC.Base.sconcat
= GHC.Prim.coerce
@(GHC.Base.NonEmpty (T14578.App (Data.Functor.Compose.Compose f g) a)
-> T14578.App (Data.Functor.Compose.Compose f g) a)
@(GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a)
(GHC.Base.sconcat
@(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a
@(T14578.App (Data.Functor.Compose.Compose f g) a))
GHC.Base.stimes
= GHC.Prim.coerce
@(b
......@@ -28,69 +32,72 @@ Derived class instances:
-> T14578.App (Data.Functor.Compose.Compose f g) a)
@(b -> T14578.Wat f g a -> T14578.Wat f g a)
(GHC.Base.stimes
@(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
forall (b :: TYPE GHC.Types.LiftedRep).
GHC.Real.Integral b => b -> T14578.Wat f g a -> T14578.Wat f g a
@(T14578.App (Data.Functor.Compose.Compose f g) a))
instance GHC.Base.Functor f =>
GHC.Base.Functor (T14578.App f) where
GHC.Base.fmap ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
(a -> b) -> T14578.App f a -> T14578.App f b
(GHC.Base.<$) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
a -> T14578.App f b -> T14578.App f a
GHC.Base.fmap
= GHC.Prim.coerce
@((a -> b) -> f a -> f b)
@((a -> b) -> T14578.App f a -> T14578.App f b)
(GHC.Base.fmap @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
(a -> b) -> T14578.App f a -> T14578.App f b
@((a -> b) -> T14578.App f a -> T14578.App f b) (GHC.Base.fmap @f)
(GHC.Base.<$)
= GHC.Prim.coerce
@(a -> f b -> f a)
@(a -> T14578.App f b -> T14578.App f a)
((GHC.Base.<$) @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
a -> T14578.App f b -> T14578.App f a
@(a -> f b -> f a) @(a -> T14578.App f b -> T14578.App f a)
((GHC.Base.<$) @f)
instance GHC.Base.Applicative f =>
GHC.Base.Applicative (T14578.App f) where
GHC.Base.pure ::
forall (a :: TYPE GHC.Types.LiftedRep). a -> T14578.App f a
(GHC.Base.<*>) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b
GHC.Base.liftA2 ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep)
(c :: TYPE GHC.Types.LiftedRep).
(a -> b -> c) -> T14578.App f a -> T14578.App f b -> T14578.App f c
(GHC.Base.*>) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f a -> T14578.App f b -> T14578.App f b
(GHC.Base.<*) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f a -> T14578.App f b -> T14578.App f a
GHC.Base.pure
= GHC.Prim.coerce
@(a -> f a) @(a -> T14578.App f a) (GHC.Base.pure @f) ::
forall (a :: TYPE GHC.Types.LiftedRep). a -> T14578.App f a
@(a -> f a) @(a -> T14578.App f a) (GHC.Base.pure @f)
(GHC.Base.<*>)
= GHC.Prim.coerce
@(f (a -> b) -> f a -> f b)
@(T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b)
((GHC.Base.<*>) @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b
((GHC.Base.<*>) @f)
GHC.Base.liftA2
= GHC.Prim.coerce
@((a -> b -> c) -> f a -> f b -> f c)
@((a -> b -> c)
-> T14578.App f a -> T14578.App f b -> T14578.App f c)
(GHC.Base.liftA2 @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep)
(c :: TYPE GHC.Types.LiftedRep).
(a -> b -> c) -> T14578.App f a -> T14578.App f b -> T14578.App f c
(GHC.Base.liftA2 @f)
(GHC.Base.*>)
= GHC.Prim.coerce
@(f a -> f b -> f b)
@(T14578.App f a -> T14578.App f b -> T14578.App f b)
((GHC.Base.*>) @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f a -> T14578.App f b -> T14578.App f b
((GHC.Base.*>) @f)
(GHC.Base.<*)
= GHC.Prim.coerce
@(f a -> f b -> f a)
@(T14578.App f a -> T14578.App f b -> T14578.App f a)
((GHC.Base.<*) @f) ::
forall (a :: TYPE GHC.Types.LiftedRep)
(b :: TYPE GHC.Types.LiftedRep).
T14578.App f a -> T14578.App f b -> T14578.App f a
((GHC.Base.<*) @f)
Derived type family instances:
......
......@@ -2,36 +2,40 @@
==================== Derived instances ====================
Derived class instances:
instance GHC.Classes.Eq a => GHC.Classes.Eq (T14579.Glurp a) where
(GHC.Classes.==) ::
T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
(GHC.Classes./=) ::
T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
(GHC.Classes.==)
= GHC.Prim.coerce
@(T14579.Wat @a (Data.Proxy.Proxy @a)
-> T14579.Wat @a (Data.Proxy.Proxy @a) -> GHC.Types.Bool)
@(T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool)
((GHC.Classes.==) @(T14579.Wat @a (Data.Proxy.Proxy @a))) ::
T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
((GHC.Classes.==) @(T14579.Wat @a (Data.Proxy.Proxy @a)))
(GHC.Classes./=)
= GHC.Prim.coerce
@(T14579.Wat @a (Data.Proxy.Proxy @a)
-> T14579.Wat @a (Data.Proxy.Proxy @a) -> GHC.Types.Bool)
@(T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool)
((GHC.Classes./=) @(T14579.Wat @a (Data.Proxy.Proxy @a))) ::
T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
((GHC.Classes./=) @(T14579.Wat @a (Data.Proxy.Proxy @a)))
instance forall a (x :: Data.Proxy.Proxy a).
GHC.Classes.Eq a =>
GHC.Classes.Eq (T14579.Wat x) where
(GHC.Classes.==) ::
T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
(GHC.Classes./=) ::
T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
(GHC.Classes.==)
= GHC.Prim.coerce
@(GHC.Maybe.Maybe a -> GHC.Maybe.Maybe a -> GHC.Types.Bool)
@(T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool)
((GHC.Classes.==) @(GHC.Maybe.Maybe a)) ::
T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
((GHC.Classes.==) @(GHC.Maybe.Maybe a))
(GHC.Classes./=)
= GHC.Prim.coerce
@(GHC.Maybe.Maybe a -> GHC.Maybe.Maybe a -> GHC.Types.Bool)
@(T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool)
((GHC.Classes./=) @(GHC.Maybe.Maybe a)) ::
T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
((GHC.Classes./=) @(GHC.Maybe.Maybe a))
Derived type family instances:
......
......@@ -2,20 +2,9 @@
T15073.hs:8:12: error:
• Illegal unboxed tuple type as function argument: (# Foo a #)
Perhaps you intended to use UnboxedTuples
• In an expression type signature:
Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
In the expression:
GHC.Prim.coerce
@(a -> Unit# @GHC.Types.LiftedRep a)
@(Foo a -> Unit# @GHC.Types.LiftedRep (Foo a))
(p @a) ::
Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
In an equation for ‘p’:
p = GHC.Prim.coerce
@(a -> Unit# @GHC.Types.LiftedRep a)
@(Foo a -> Unit# @GHC.Types.LiftedRep (Foo a))
(p @a) ::
Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
• In the type signature:
p :: Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
When typechecking the code for ‘p’
in a derived instance for ‘P (Foo a)’:
To see the code I am typechecking, use -ddump-deriv
In the instance declaration for ‘P (Foo a)’
......@@ -3,12 +3,9 @@ T4846.hs:29:1: error:
• Couldn't match type ‘Bool’ with ‘BOOL’
arising from a use of ‘GHC.Prim.coerce’
• In the expression:
GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool) ::
Expr BOOL
GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool)
In an equation for ‘mkExpr’:
mkExpr
= GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool) ::
Expr BOOL
mkExpr = GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool)
When typechecking the code for ‘mkExpr’
in a derived instance for ‘B BOOL’:
To see the code I am typechecking, use -ddump-deriv
......
......@@ -9,18 +9,14 @@ deriving-via-fail5.hs:8:1: error:
the instance declaration
at deriving-via-fail5.hs:(8,1)-(9,24)
• In the expression:
GHC.Prim.coerce
@(Int -> Identity b -> ShowS)
@(Int -> Foo4 a -> ShowS)
(showsPrec @(Identity b)) ::
Int -> Foo4 a -> ShowS
GHC.Prim.coerce
@(Int -> Identity b -> ShowS) @(Int -> Foo4 a -> ShowS)
(showsPrec @(Identity b))
In an equation for ‘showsPrec’:
showsPrec
= GHC.Prim.coerce
@(Int -> Identity b -> ShowS)
@(Int -> Foo4 a -> ShowS)
(showsPrec @(Identity b)) ::
Int -> Foo4 a -> ShowS
@(Int -> Identity b -> ShowS) @(Int -> Foo4 a -> ShowS)
(showsPrec @(Identity b))
When typechecking the code for ‘showsPrec’
in a derived instance for ‘Show (Foo4 a)’:
To see the code I am typechecking, use -ddump-deriv
......@@ -39,14 +35,12 @@ deriving-via-fail5.hs:8:1: error:
the instance declaration
at deriving-via-fail5.hs:(8,1)-(9,24)
• In the expression:
GHC.Prim.coerce
@(Identity b -> String) @(Foo4 a -> String) (show @(Identity b)) ::
Foo4 a -> String
GHC.Prim.coerce
@(Identity b -> String) @(Foo4 a -> String) (show @(Identity b))
In an equation for ‘show’:
show
= GHC.Prim.coerce
@(Identity b -> String) @(Foo4 a -> String) (show @(Identity b)) ::
Foo4 a -> String
@(Identity b -> String) @(Foo4 a -> String) (show @(Identity b))
When typechecking the code for ‘show’
in a derived instance for ‘Show (Foo4 a)’:
To see the code I am typechecking, use -ddump-deriv
......@@ -64,18 +58,14 @@ deriving-via-fail5.hs:8:1: error:
the instance declaration
at deriving-via-fail5.hs:(8,1)-(9,24)
• In the expression:
GHC.Prim.coerce
@([] (Identity b) -> ShowS)
@([] (Foo4 a) -> ShowS)
(showList @(Identity b)) ::
[] (Foo4 a) -> ShowS
GHC.Prim.coerce
@([] (Identity b) -> ShowS) @([] (Foo4 a) -> ShowS)
(showList @(Identity b))
In an equation for ‘showList’:
showList
= GHC.Prim.coerce
@([] (Identity b) -> ShowS)
@([] (Foo4 a) -> ShowS)
(showList @(Identity b)) ::
[] (Foo4 a) -> ShowS
@([] (Identity b) -> ShowS) @([] (Foo4 a) -> ShowS)
(showList @(Identity b))
When typechecking the code for ‘showList’
in a derived instance for ‘Show (Foo4 a)’:
To see the code I am typechecking, use -ddump-deriv
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment