GHC/Stand-alone deriving declarations
m (GHC/StandAloneDeriving moved to GHC/Stand-alone deriving declarations)
m (Remove level 1 heading as per wiki guidelines)
Revision as of 15:17, 1 November 2006
Bjorn Bringert has recently implemented "stand-alone deriving" declarations, documented briefly here . There are a few loose ends which I summarise here:
The current syntax is
deriving Show for T
There seems to be a consensus that this would be better:
derive instance Show T
2 Context on the declaration
Because it looks like a regular instance declaration, it would arguably be reasonable to require the programmer to supply the context. It seems odd to say:
derive instance Show (T a)
and perhaps cleaner to say
derive instance Show a => Show (T a)
(At the moment, the compiler figures out the appropriate context, but at some point that automation may run out of steam.)
3 Interaction with "newtype-deriving"
GHC's "newtype deriving mechanism" (see ) should obviously work in a standalone deriving setting too. But perhaps it can be generalised a little. Currently you can only say
deriving C a for Foo
newtype Foo = F Int newtype Bar = B Bool derive instance C Foo Bar
Which of these thee instances do we want?
instance C Foo Bool => C Foo Bar instance C Int Bar => C Foo Bar instance C Int Bool => C Foo Bar
The obvious way to signal this is to give the instance context (just as above). This is perhaps another reason for having an explicit instance context in a standalone deriving declaration.
Incidentally, notice that the third of the alternatives in the previous bullet unwraps two newtypes simultaneously. John Meacham suggested this example:
class SetLike m k where instance SetLike IntSet Int where newtype Id = Id Int newtype IdSet = IdSet IntSet derive instance SetLike IntSet Int => SetLike IdSet Id
4 Duplicate instances
Suppose two modules, M1 and M2 both contain an identical standalone deriving declaration
derive Show T
Then, can you import M1 and M2 into another module X and use show on values of type T, or will you get an overlapping instance error? Since both instances are derived in the very same way, their code must be identical, so arguably we can choose either. (There is some duplicated code of course.)
This situation is expected to be common, as the main use of the standalone feature is to obtain derived instances that were omitted when the data type was defined.