[Haskell-cafe] FW: Haskell

[Artem V. Andreev]

Simon Peyton-Jones <simonpj at microsoft.com> writes:

> Dear Haskell Cafe members
>
> Here's an open-ended question about Haskell vs Scheme.  Don't forget to cc Douglas in your replies; he may not be on this list (yet)!
>
> Simon
>
> -----Original Message-----
> From: D. Gregor [mailto:kerrangster at gmail.com]
> Sent: 30 March 2008 07:58
> To: Simon Peyton-Jones
> Subject: Haskell
>
> Hello,
>
> In your most humble opinion, what's the difference between Haskell and
> Scheme?  What does Haskell achieve that Scheme does not?  Is the choice less
> to do with the language, and more to do with the compiler?  Haskell is a
> pure functional programming language; whereas Scheme is a functional
> language, does the word "pure" set Haskell that much apart from Scheme?  I
> enjoy Haskell.  I enjoy reading your papers on parallelism using Haskell.
> How can one answer the question--why choose Haskell over Scheme?

In my most humble of opinions, the comparison between Haskell and Scheme is just
methodologically incorrect. What I mean is that these are actually different
kinds of entities, despite they both are called "programming languages".  In
particular, Scheme is nothing but a minimal core of a programming language --
despite it being Turing complete, one can hardly write any serious, "real-world"
program in pure Scheme, as defined by IEEE or whatever. So Scheme is, to my
mind, what is it called -- a scheme, which different implementors supply with
various handy additions. And we do not have any "leading" Scheme implementation
that would count as a de facto definition of a "real" Scheme language. Thus we
conclude that the term "Scheme" denotes not a programming language, but rather a
family of programming languages.

On the other hand, Haskell, as defined by The Report (well, plus FFI addendum)
is a true solid "real-world" language which can actually be used for real-world
programming as it is. And we do have a dominating implementation as well, etc
etc.

Thus: a methodologically correct comparison should be done either between two
implementations (Bigloo vs GHC, or MIT Scheme vs Hugs or Stalin vs Jhc or
whatever you like) or on the level of PL families and then we'd have Scheme
versus Haskell+Helium+Clean+maybe even Miranda+whatever else. In the latter case we'd
have two choices again: comparing "upper bounds" or "lower bounds", that is,
comparing sets of features provided by any representative of a class or by *all*
representatives. Needless to say that the outcome would differ drastically
depending on which way we take.


-- 

					S. Y. A(R). A.