Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] Observations on OCaml vs. Haskell
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: John Goerzen <jgoerzen@c...>
Subject: [Caml-list] Observations on OCaml vs. Haskell
I recently decided I ought to learn a bit about Haskell.  I've done so, 
and while it is remarkably similar to OCaml in many ways, there are a 
few things I really like about Haskell.  At first glance, to this 
relative latecomer to both languages, the Haskell approach to these 
things looks very appealing.  I am wondering if you know of drawbacks 
of their approach, and why the OCaml designers opted for something 
different.

1. Haskell lists resemble OCaml Streams

This is, in fact, one of my main complaints about OCaml lists: that they 
are a distinct type from OCaml streams.  Streams have a lot of power, 
and having to convert back and forth between the two doesn't always 
make a lot of sense.  I've doing things like written versions of map or 
filter for streams, making them lazy, which results in a very powerful 
approach to things like file reading, etc.  It's annoying to not be 
able to re-use all the existing list-related functions on streams.

In Haskell, there is no separate stream type; a list is a stream.

2. Haskell strings are lists of characters

It's annoying that strings aren't normally processed this way in OCaml, 
and even more annoying that (^) or (::) cannot be used in pattern 
matching over strings.  I like Haskell's approach.  The list 
concatenation operator is the same as the string concatenation operator 
in Haskell.

3. The Num typeclass

I've written several functions that can work with a "number-like" type.  
I don't really care if I get an integer, Int32, Int64, float, or what.  
But since these are all different types in OCaml, I am forced to care, 
right down to using +, +., or Int64.add to perform basic arithmetic.  
The Num typeclass in Haskell neatly solves that whole problem; I could 
take a Num, use a unified set of operators, and produce the appropriate 
result.

For #1 and #2, the only reasons I can think of for OCaml's approach 
involve performance.  For #3, I can't really come up with any good 
reason, since one can always specify a type of Int or whatever in 
Haskell anyway.

OCaml enlightenment appreciated :-)

Thanks,
John

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners