Kevin writes:
| I strongly agree that Haskell can become a *much* more
| powerful language
| with out losing any of clean syntax or semantics. However,
| when ever I
| bring up limitations of Haskell type system on this list I either get
| ignorance or resistance.
I strongly agree that Haskell could be better. But it is not easy
to come up with clean designs for the sort of extensions you would like.
- True ad-doc polymorphism
- Built in dynamic typing system.
- State Encapsulation
- A solution to the abilities arising from multi parameter type classes.
- Syntactic sugar for supporting OO programming styles
It is easier to identify the problem, that to identify a solution.
It is easier to identify a solution than to describe that solution
completely and precisely.
It is easier to describe the solution precisely than to implement it.
I think some of the resistance Kevin feels may have something of
the flavour of "lets wait to find a good solution, rather than
whip up a half-baked one".
Dynamic types is a good example. There is a large design space of
possible solutions, and it's not clear (to me) which is best. I don't
think any consensus has emerged.
Ad hoc polymorphism is another good example. Carlos's System CT
goes a way towards a fairly fully-described solution; Mercury implements
another variant. I don't know how the two compare. It is controversial
whether the interaction of ad-hoc polymorphism with type-class overloading
makes the whole thing unmanageably complex.
On the MPTC issues, a good solution does indeed seem to be emerging,
as Mark mentions.
None of this is to say that dynamic types or ad-hoc polymorphism
is a bad thing. But I think it's a misconception to interpret the
feedback Kevin has received as closed-mindedness. It's just a lot of work
to work out to describe and implement these sort of extensions; even
laying aside the expressiveness vs simplicity tradeoff, which itself
is a real issue.
What can be done to hurry the process along? One constructive thing
would be for enthusiasts for a particular extension to move towards
complete, precise descriptions of what they would like; and to
implement the feature in Mark's type checker (the one he's just released).
Doing this doesn't guarantee that a feature will make it into Haskell,
but it does make it more likely. The way to guarantee that a feature
will make it into a particular compiler is to implement it. Both Hugs
and GHC are open source, and work from a CVS repository you can get to
over the network.
Haskell belongs to you. (Sound of violins.)
Simon
