So, I found myself doing something like this:
newtype T x = T x deriving (Eq, Ord, ...)
And I thought this was annoying, so I'm thinking about making a package, using Template Haskell, that adds all the instances in base.
Perhaps it could even be more flexible than just dealing with what's above.
Firstly, it seems like Template Haskell can only spit out declarations, so I think I want to use standalone deriving. In general, I think I want to produce declarations something like this:
deriving instance (F x1, F x2, ... , F xn) => T x1 x2 x3
Where F is replaced by Eq, Ord, etc.
But the right hand side could be a bit more complex, for example:
deriving instance (F x1, F x2, ... , F xn) => T x1 (Maybe x2) x3
Or maybe even
deriving instance (F x1, F x2, ... , F xn) => T x1 (T2 x2 x3)
You could even have repeats:
deriving instance F x => T x x
Lets simplify things for a moment here, and assume there is only one parameter on the left. So we're looking at instances like this:
deriving instance F x => T (some stuff involving x)
I figure what I need is a function like the following:
(Name -> Type) -> Q [Dec]
Then I keep each class in base in a list (i.e. Eq, Ord etc). Then for each class of that list, I create a dummy variable, apply the class to it on the left hand side of the =>, and pass it to the Name -> Type argument passed to get the right hand side of the =>. I can the spit that out as a splice.
I think I can do the Template Haskell for the above function, but the problem is, how does a user use that Template Haskell function?
I think something like \x -> [| UserT x x |] won't work, will it?
I want the user to be able to do something like:
data A t = A t (Maybe t)
deriveClasses (\x -> A x)
How can I make this sort of thing nice for the end user? I hope this question makes some sort of sense, the thing I'm currently most focused on is a form that's easy for the user to use. When it comes to the actual writing of the Template Haskell I think I should be able to handle that.