John
This is good stuff, but I fear that in 3 months time it'll be buried in our
email archives. In contrast, your original web page is alive and well, and we
were able to start our discussion based on it
So can I suggest that you transfer your web page to the Haskell' wiki (simply a
convenient, editable place to develop it), or to the haskell.org wiki
(likewise). And that, as the design gets fleshed out, you try to reflect the
current state of play there? I don't want this work to be lost!
Ok, on to your email:
=============== Desugaring the class alias decl =================
| there are two different desugaring rules, one for instances, one for the
| alias appearing anywhere other than an instance declaration:
|
| > g :: A a => a -> b
| > g = ...
|
| translates to
|
| > g :: (S a, C1 a, C2 a) => a -> b
| > g = ...
|
| the triplet of (S a, C1 a, C2 a) is completely equivalent to (A a) in
| all ways and all places (other than instance heads)
Notice that this part *is* exactly true of a superclass with no methods
class (S a, C1 a, C2 a) => A a where {}
That's not necessarily bad; but it does make it harder to figure out when to
user a superclass and when to use a class alias. Does that make sense?
In fact, I suggest the following (**): the class alias
> class alias S a => A a = (C1 a, C2 a) where
> f1 = nd1
desugars to
class (S a, C1 a, C2 a) => A a
The class alias decl *also* affects the desugaring of instances, still to come,
but by desugaring the class alias into an ordinary class, you don't have to say
*anything* about
g :: (S a, C1 a, C2 a) => a -> b
vs g :: (A a) => a -> b
=============== Desugaring instanc decls =================
| now for instance declarations
|
| > instance A a where
| > f2 = bf2
|
| expands to
|
| > instance (S a) => C1 a where
| > f1 = nd1
|
| > instance (S a) => C2 a where
| > f2 = bf2
| > f3 = d3
Do you really mean that? Presumably 'a' is not a type variable here?
Furthermore, instance decls typically have a context. Unless I have profoundly
misunderstood, I think you mean this:
instance (Foo a, Bar b) => A (a,b) where
f1 = bf1
expands to
instance (Foo a, Bar b) => C1 (a,b) where
f1 = nd1
instance (Foo a, Bar b) => C2 (a,b) where
f2 = bf2
f2 = d3
Notice the *absence* of an instance for (S (a,b)). It's up to the *user* to
ensure that there is such an instance, perhaps, say
instance Foo a => S (a,b) where ...
In this way S is behaving just like any ordinary superclass. If we have
class S a => T a
then given an instance
instance (Foo a, Bar b) => T (a,b)
it's up to the user to ensure that there is an instance for S (a,b).
With the desugaring (**) I proposed above, we'd add one more instance:
instance (Foo a, Bar b) => A (a,b)
| Hopefully the generalization to arbitrary numbers of classes is clear...
I'm not sure either way. Let's get this written up first.
Simon
_______________________________________________
Haskell-prime mailing list
Haskell-prime@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-prime
