Simon Marlow wrote:
On 26 January 2006 09:59, John Hughes wrote:
The solution I favour is simply to use *different syntax* for the two forms of binding, so that a definition is monomorphic, and computed at most once, if it uses the monomorphic binding operator, and polymorphic/overloaded, computed at each use, if it uses the other. Whether it's a function definition or not is irrelevant, as is whether or not it carries a type signature.
The trick is finding good syntax. I suggest = for bind-by-name, and := for bind-by-need.
The reasoning for the proposal makes complete sense to me, but I don't feel the proposed solution strikes the right balance. The MR is a subtle point that we don't want to have to burden newcomers to the language with, but having two forms of binding is a fundamental part of the language design that would surely crop up early on the Haskell learning curve. John - how do you envisage teaching this?
I don't think it's hard. I would just teach students to define functions with =, and "variables" with :=. I tell my students to write type signatures at the beginning anyway, so they don't risk being bitten by the M-R anyway. Beginning students just do what you tell them, and they already think of function and variable definitions as different. Learning a different syntax for one of them would not be a problem. Once they've mastered basic programming and start getting interested in things like overloading, then you have to explain how the M-R works. I'd much rather explain =/:= than try to teach them how you know whether a definition is shared or not right now.
I wonder if there's an alternative solution along these lines:
- We use ParialTypeSignatures to make bindings monomorphic:
http://haskell.galois.com/cgi-bin/haskell-prime/trac.cgi/wiki/PartialTyp eSigs
eg.
x :: _ x = (+1)
- we make it a static error for a variable bound by a simple pattern binding ("x = e") to be overloaded, unless a type signature is given. The error message would explain the problem, and how to fix it. Alternatively, we make it a strong warning.
It seems to me that the partial type signatures extension provides a lot of bang for the buck - it gives us a way out of the MR in addition to partial type signatures.
I don't like this. Once students start dropping type signatures (which they do pretty soon for local variables in where-clauses), they would sometimes-- unpredictably as far as they're concerned--get an error message telling them they must put one back in again, but it's enough to write x :: _. Can you imagine explaining to an average student in the first year why they MUST put in a type signature, but it doesn't need to include a type??? Don't underestimate the difficulties many students already face. At this stage, they're not even completely sure what the difference is between a type and a value, let alone a type and a class! Understanding the effect of the presence or absence of a type signature is beyond most students until much, much later. If we replace or revise the M-R, the replacement should be very, very simple. The M-R in its present form is a clever, and not terribly complicated solution --but complicated enough to have caused no end of trouble over the years. Let's not be clever, let's be straightforward and explicit: two binding forms, two notations. John