[Haskell-cafe] let vs do?

[Dave Bayer]

On Jun 28, 2007, at 9:49 PM, Stefan Holdermans wrote:

>> That way you would have to use monads everywhere.
>
> As you already hinted at in a later message, this has to do with  
> let-bindings being potentially polymorphic and monadic bindings  
> being necessarily monomorphic:

Are there papers that prove this need be the case in any language, or  
are we simply now trapped into this for the moment by some design  
choices?

If monads weren't late to the party, with clumsy notation left over  
from the core language, would we really mind a language where one has  
"to use monads everywhere" ? The trick would be to design them in so  
seamlessly that a Perl/Python/Ruby scale mainstream _thought_ they  
were just using another imperative language, that happened to scale  
_very_ gracefully to eight core machines and such because of the  
underlying semantics.

Compare a Haskell do statement to a Lisp expression. In the Lisp  
expression the first element is special, a convention of the eval  
loop. In the Haskell do expression, every line is equally special,  
and type information is used to combine the lines, inserting implied  
combinators. This is a fascinating variation on Lisp rules, alas  
restricted to a couple of situations, akin to the special syntax for  
tuples and lists. I see potential for a whole language that worked  
this way, opened up to let the programmers control this process  
without waiting for an implementation to take their suggestions  
(think history of arrows) piecemeal.

Here's a different analogy: People like Haskell parsing because it  
looks so much like the definition of the grammar itself. So step down  
a rung, to regular expressions, and imagine a toy language where a  
regular expression _IS_ by itself, with no further ado, a fully  
working program. One is immediately led back to the same idea as  
Haskell do expressions: Two pieces of program, juxtaposed next to  
each other, silently "multiply" to combine into a larger program,  
with type rules guiding the multiplication process.

That sure reads to me like a description of how do statements work in  
Haskell, so unleash them?