On Monday 28 January 2008 14:23:01 you wrote:
> Jon Harrop wrote:
> >There are also many features that I would like to steal from other
> > languages:
> >
> >. The IDisposable interface from .NET and F#'s "use" bindings.
>
> Is there a reason that Gc.finalise doesn't work?

Absolutely: Gc.finalise is only probabilistic whereas IDisposable is 
deterministic. IDisposable guarantees deallocation of resources by a certain 
point. (This is why you should never use Gc.finalise alone to manage the 
collection of external resources!)

So you write a "use" binding:

  let read_first_line file =
    use ch = open_in file in
    input_line ch

and it gets translated into:

  let read_first_line file =
    let ch = open_in file in
    try input_line ch finally
    ch#dispose

where the "dispose" method that was automatically inserted at the end of the 
scope of the "use" binding calls "close_in" in this case to deallocate the 
external resource (a file handle in this case but it could be anything with a 
dispose method).

This is easy to implement and will remove a world of pain when doing IO in 
OCaml.

> >and some more involved ones like operator overloading.
>
> I *hate* operator overloading.  My experience in C++ is for every time
> this feature is used legitimately (i.e. to implement complex numbers or
> whatever), it's abused 10 times- and that's ignoring C++'s use of the
> bit shift operators << and >> for I/O, and the use of + for string
> concatentation, both of which I'd argue really should be considered
> abuses, as far as I'm concerned. And this is ignoring the difficulty of type
> inference in the presence of overloaded operators.

You're looking in the wrong direction.

Look at F# to see how OCaml + overloading done right can be hugely beneficial. 
OCaml has fallen far too far behind to catch up completely but we could take 
some baby steps in this direction, just like SML's ad-hoc polymorphic 
approach but with a wider range of types (complexes, vectors, matrices).

This is fairly easy to implement and, again, will remove a world of pain when 
doing arithmetic in OCaml.

> The best way to handle this IMHO is Haskell-style type classes.  Which
> solves the whole type inference problem, and rules most of what I
> consider abuses of operator overloading (for example, if you have a '+'
> operator, you also have to have a '*' operator- and what is "foo" *
> "bar"?).  But this is a very non-trivial change to the language.

Type classes are more powerful but they also make performance less predictable 
(the dictionary may or may not be optimized away). They are also 
unachievable, as you say.

-- 
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/products/?e