I've been using Haskell a little for the past year or so and I like
quite a few of it's features, more recently I thought I'd look into
O'Caml and I've been impressed by it's speed and versatility but I was
wondering if it had some features found in Haskell.

The main one I would like is the type assertion facility of Haskell.
For example, one might write:
mul :: Int -> Int -> Int
mul a b = a * b
The Haskell compiler will deduce the type of mul from the second line
in a similar way to O'Caml and if it does not match the first line an
error is raised.

I find that this catches a lot of my mistakes and it would be great if
O'Caml has a similar way to check whether the implied type of a
function matches (or is a subtype of) an explicit definition.

Another feature I would like is whether it is possible to define
custom operators that can be put between it's operands rather than in
front of them. For example if max gives the maximum of two arguments
it can be applied normally, i.e. "max 2 3" will return 3, but "2
`max` 3" will also return 3.
Also if a function is named using operator symbols it can be used as
an operator, e.g if &&& is defined as:
(&&&) :: Int -> Int -> Int
x &&& y = max x y
then "2 &&& 3" will return 3
This can lead to some very easy to read programs so I would like to
know if either or both of these ways of defining operators has a
equivalent in O'Caml.

Thanks in advance,
Steven Murdoch.


--
email: steven@murdomedia.net
web: http://www.murdomedia.net/
PGP/GnuPG keys: http://www.murdomedia.net/keys.html

-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr