On Tue, 10 Mar 1998, Adam P. Jenkins wrote:
> Brian Rogoff writes:
>  > Hi Caml'ers,
>  > 	One of the things I miss the most when I'm working in Caml is 
>  > overloading. There are numerous situations, such as arithmetic, linear 
>  > algebra (where I may want multiplication between scalars, vectors, 
>  > matrices, and higher order tensors), I/O (read/write/open), etc. where 
>  > it is IMO the "right thing". Are there any plans to add some form of 
>  > overloading to Caml in the future? I know that the Haskell folks plan to 
>  > remove the single parameter restriction in type classes and gain more 
>  > expressiveness in these areas, but none of the ML family of languages 
>  > I know of support any overloading.
>  > 
>  > 	My experience with overloading in Ada is almost entirely positive.
>  > 
> 
> I too have missed overloading in ML/Caml.  However, it seems to me
> that function overloading is opposed to type inference; you can't have
> both at the same time without too many explicit casts, which destroys
> the point of function overloading.

Yes, I know the marriage of the type inference and overloading is a
difficult one. 

> Are there any languages which have
> both automatic type inference and function overloading?
> 
> Adam

Haskell has some limited ad-hoc polymorphism via its type classes, and 
there was some work at adding a form of ad-hoc polymorphism to Caml. It is 
on the Caml page, look for "extensional" polymorphism. I haven't read it
yet. Perhaps some of the Caml implementors can comment on what it
describes. Also under Francois Rouaix's page is a description of "Alcool", 
which has another approach to overloading in an ML like language.

C++ (which has overloading) supports a limited form of type inference for 
templated functions. There was a proposal to add something similar to Ada 
in an old Tri-Ada proceedings. It is usually called "automatic instantiation"
or something similar in those communities. 

In response to Frank Christoph, I am using O'Caml. What I really want in 
this case is overloading, not OO. I think the reasons for this desire and 
the arguments for overloading are known, so I won't repeat them unless 
someone wants me to. I have seen O'Labl, but since I use Windows NT at 
home I haven't used it yet (when I get Linux that will change ;-). It
looks very promising, and I also miss named parameters from Ada, but
still, it isn't quite what I want.

-- Brian