On 19/01/07, Dirk Thierbach <dthierbach@gmx.de> wrote:
[Please don't reply directly to me AND to the list, just to the list
is enough. Thanks.]
Sorry... didn't mean to... I mean, I didn't know there's a problem. I don't get mail that's sent to me AND the caml-list twice...
On Fri, Jan 19, 2007 at 11:35:36AM +0100, Tom wrote:
> On 19/01/07, Dirk Thierbach <
dthierbach@gmx.de> wrote:
> Well, in some sense, generic value overloading is somewhat like Haskell's
> type classes,
Yes. That's exactly what type classes are for -- overloading of functions
(including infix operators).
No, no, you misunderstood me. Type-classes are run-time dispatched. What I want is static/compile-time overloading. I meant they are similar for the type inference system. My type system should use roughly the same algorithm for inference that Haskell uses, but it should infer the typeclasses (the possible types a type variable can be instantiated) automatically.
Actually, I don't even want such types be extensible - one function will always have either ONE input type (int -> int), or ANY input types ('a -> 'a), but two such functions might have the same NAME. The compiler's task isn't to supply all possible implementations of some mathematical function - that's the programmers task:
if I define
let negate a = - a
it will not have all possible types (int, float, complex, ...) but only one of them. For another type, I have to define it again:
let negate a = - a
I can also specify types:
let negate a : complex = - a
(and of course ask the compiler to do it for me:
overload let negate a = - a
but that's only a shortcut - internally, it would be expanded into n functions, each ranging over one of n types. )
My overloading would be more C++ / C# / Java-like - but the inference technique should be similar to Haskell's.
And that's exactly what the Haskell compiler does (see below).
BTW,
the important thing is the type variable after the predicate, just
ignore the forall's for the moment. So the above type is nonsense, a
possible example type could look like:
Sorry, I don't know Haskell that well. But you know what I meant :)
> Can Haskell overload values? And functions by their return type?
It can overload integer and fixed point literals (in the way described
above). It cannot overload any other "values" (whatever that should
be :-).
By overloading values, I mean:
let null = 0
let null = false
if null then 1 else null
- Tom