> > John notes that recursive type synonyms may lead to less comprehensible
> > error messages. Good point!
> As John says, experimentation would be a good idea. Any takers?
> Cheers, -- P
A simple suggestion (for experimentation): All recursive types needed to
typecheck a program must be ex
John notes that recursive type synonyms may lead to less comprehensible
error messages. Good point!
As John says, experimentation would be a good idea. Any takers?
Cheers, -- P
The biggest worry for me in using graph unification for type checking is the
potential effect on error messages from the type checker. While dropping
the restriction makes some sensible programs well-typed, it also makes some
senseless programs well-typed, thus delaying the moment at which type
Phil Wadler wrote:
> Mark suggests that Mu types might be better that recursive type
> synonyms. I think of them as pretty much equivalent, and it's
> simply a question of whether one makes the `mu' syntax accessible
> to the user. One certainly needs `mu' or an equivalent internally
>
[I hear cries of Haskell 2]
Phil Wadler writes:
> The suggestion is:
>
> Remove the restriction that type synonym
> declarations must not be recursive.
>
> [...]
>
> The obvious way to go is for someone to implement it first, to
> make sure it's not difficult. Mark Jones, have you
Mark suggests that Mu types might be better that recursive type
synonyms. I think of them as pretty much equivalent, and it's
simply a question of whether one makes the `mu' syntax accessible
to the user. One certainly needs `mu' or an equivalent internally
for doing the typechecking. The adva
Mark Jones gives the following alternative definitions for Lists:
> type List a b = b -> (a -> b -> b) -> b
> nil :: List a b
> nil f g= f
> cons :: a -> List a b -> List a b
> cons x xs f g = g x (xs f g)
> fold :: b -> (a -> b ->
To illustrate a need for recursive type synonyms, Joe suggests the example:
| nil f g = f
| cons x xs f g = g x xs
|
| fold f z xs = xs z (\x xs -> f x (fold f z xs))
Indeed, this doesn't type check in Haskell, and recursive type synonyms
would fix it. (So
Phil suggests that Haskell 1.3 might:
| Remove the restriction that type synonym
| declarations must not be recursive.
|
| In other words, one could write things like
|
| type Stream a = (a, Stream a)
|
| which is equivalent to the type (a, (a, (a, ...))).
I have some res
Phil writes,
| While we are proposing things, here's a further suggestion.
| The great thing about this suggestion is that it only *removes*
| a restriction, and makes the language definition simpler.
| It is fully backward compatible.
|
| The suggestion is:
|
| Remove the restriction that
10 matches
Mail list logo
