Re: [Caml-list] Haskell vs OCaml

["blue storm" <bluestorm.dylc@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 3295 bytes --]

So it seems the debate went on anyway. I had written something, but when
just before posting i saw Brian Hurt's post, and decided not to. It now
seems i was wrong, and actually (when reading the others) my post seems
quite balanced after all.

I'm not saying that the other posters are biased in any way. But i have the
point of view of someone trying to learn a language "for fun" and in order
to discover interesting features or novel point of views. It seems Haskell
do much better in that context that in the "use it to do something useful in
the cruel world" context used so far.

So here is my original post :

I'm afraid your question is a bit too general (and it seems strange to ask
that on the mailing-list of one of the projects, while asking for a balanced
answer).

The main differences are :
OCaml is impure (imperative features in the language), Haskell is pure.
OCaml is strict, Haskell is lazy.
Ocaml has modules, Haskell has type classes.

If you're coming from the imperative land, OCaml is, in my opinion, easier
to learn.
It is also a good choice to begin with OCaml because everything you learn
with the OCaml basics can be reused for learning Haskell (the converse is
also true, but then you have to learn lazy evaluation first, wich is a
non-trivial shift, and is vastly less used in OCaml).
Haskell is certainly worth the effort, but my personal opinion is that
learning OCaml first is a good idea. Moreover, for "real world" application,
you may prefer OCaml over Haskell.

The syntax are different, but not so much (before learning haskell, i could
generally understand the purpose of tiny haskell sources). I have heard some
people say they prefer the Haskell syntax, but this is more a matter of
taste (and not very relevant if you want to learn something from the
language semantics). Both have their ugly sides.

Idiomatic OCaml implementations tend to produce more efficient than
Idiomatic Haskell implementations (but Haskell compilers are getting better
and better everyday (for Haskell performances to be good, compilers have to
do lots of clever and not so simple optimizations), and Haskell is faster
than most (scripting) languages used these days anyway).

The Haskell standard library is bigger than the Ocaml one, but this is
probably not an advantage for beginners (because this means more time spent
in browsing the doc, while playing with the language and reimplementing
functions yourself is much more interesting). Haskell program thus tends to
be more terse and "higher-level" (because of reusing a lot of higher-order
combinators in the stdlib): OCaml is also very expressive, but the
simplicity of the stdlib tends to keep people on simpler things.

To the advanced programmer, both languages have interesting advanced
features to offer. Haskell tends to specialize in sophisticated type system
features, whereas OCaml has an interesting object system, and polymorphic
variants. Both languages have very interesting derivatives, specific
languages intended to explore a specific area (concurrency, metaprogramming,
etc...).

Camlp4 is a flexible and powerful Ocaml preprocessor. Haskell has some tools
in that direction, that i have never used (so i'm mostly guessing here), but
they seem to be even less supported and used inside the community.

[-- Attachment #2: Type: text/html, Size: 3466 bytes --]