[Hugs-users] Hugging to bits

[Anthony Clayden]

Thank you for the encouraging words to my previous thread. I can report
Hugs is indeed easy to hack.

Getting to build from source was only mildly painful. (Mostly due to my
total ignorance of Unix.)

After being so used to Functional thinking, it is a wrench going back to
programming in procedural code (C/C++) with side-effects and global
variables. But I'm only tweaking the logic, not building anything from the
ground up. (I've not before programmed in earnest in C, but it seems close
enough to BCPL from my varsity days.)

Chiefly, as I suspected, Hugs has a very firm foundation to start from.
There's a deal of static type/class/instance analysis built up from the
program text, which means I can easily detect the conditions under which I
want to relax some of Hugs well-principled rules. (I'm implementing
well-principled but more subtle rules.)

So I have a modified version of the FD consistency rules, that supports
expressing a type-level type equality test, but avoids the bogusness in GHC
Trac #10675. With the equality test I can now express all the examples in
the HList paper [2004] -- those guys abandoned Hugs.

I have a better version of the instance overlap rules, determined
statically from examining instance heads. IMO GHC's deferred checking is
far too shonky: you think your instances are OK then many moons later you
(or more likely somebody using your library) gets puzzling rejections to do
with overlaps.

A quick q in case anybody's listening: Hugs used to have something called
'Multi-instance' overlap resolution. There's references to it in the code
and older documentation. But it's broken and was withdrawn. Anybody know
what it was trying to do or where I can find docos? It seems it was trying
to defer checking much like GHC, in which case I won't pursue it.

I'm now working through an approach for my 'Instance Apartness Guards'
proposal
https://github.com/AntC2/ghc-proposals/blob/instance-apartness-guards/proposals/0000-instance-apartness-guards.rst

I can express all the examples there, including the very awkward Andy A-M
one (using classes/instances with FunDeps rather than type families). But
it needs inserting extra instances and lots of instance constraints for
type improvement.

So my next hack is to change the rules for overlap resolution where there's
also FunDep(s). Again this can all be done at static analysis time: Hugs
determines the sequence to try instances as it processes/validates each
instance.

It is a joy to work in a version of Haskell that has what I want; and not a
load of cruft I don't want, but which causes continual obfuscation. Thank
you again to the Hugs team.

AntC
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/hugs-users/attachments/20180728/4bf629ef/attachment.html>