> > 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
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
In view of the recent suggestion of Philip Wadler re: Recursive type synonyms
>The suggestion is:
>
> Remove the restriction that type synonym
> declarations must not be recursive.
>
>In other words, one could write things like
>
> type Stream a = (
errors are discovered.
For example, consider
iterate 0 f x = x
iterate (n+1) f x = f (iterate n x)
At present this produces an occurrence type error. With recursive type
synonyms, it would be well-typed with the type
iterate :: Num a => a -> b -> b
where b = (b->b) -> b
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'
[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 typ
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 ->
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 type synonym
decl
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
woul
rated just for the purpose.
Dropping the restriction on recursive type synonyms gives a poor man's
version of recursive types. Maybe we could find a way to support full
recursive types instead, using explicit mu's in type expressions? For
example, the stream type might become:
type
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
12 matches
Mail list logo
