Template Haskell stability

[Iavor Diatchki]

Hello,

I am not sure if this is the right list to post to, but I suspect
template-haskell is mostly modified by GHC folk, which is why I chose to
post here, and there is no maintainer listed, based just the `libraries`
list.

Template Haskell is a very useful tool, but I am always quite wary of using
it, because it is so unstable.   I understand the need to change the
syntax, as the language evolves, but I feel that changes are made without
any consideration for backward compatibility, which is very unfortunate.

To give you an example, I am currently using GHC 9.6.4, and I am working on
a small TH utility.  I need to make a tuple expression, but of a dynamic
size, so I can't use the special syntax, and need to use a function to do
so.  So I am using the function, `tupE`, which has the following type:

    tupE :: Quote m => [m Exp] -> m Exp

This is quite nice and unsurprising.   When I look oh `hackage`, however,
the type of this function has changed, now it is:

   tupE :: Quote m => [m (Maybe Exp)] -> m Expr

So what do I do?  Basically I should not use this function, because as soon
as I upgrade the compiler everything will break!  Furthermore there is no
documentation at all to explain what this function is supposed to do (I
can't fathom why it is taking `Maybe` as arguments), or when it changed,
etc.

So my plea would be---change the syntax at will, but let's try to keep the
convenience functions that build the syntax stable: instead of changing
functions, it is just as easy to add a new function.  I understand that
sometimes things need to change, but then we should describe what changed,
and in which versions.   I don't think these are hard things to do, and I
really think it will have great benefit to everyone using TH.

Cheers,
-Iavor
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-devs/attachments/20240310/6c6ecc81/attachment.html>