caml-list - the Caml user's mailing list
 help / color / mirror / Atom feed
* RE: [Caml-list] operator overloading
@ 2002-04-13  5:26 Issac Trotts
  0 siblings, 0 replies; 51+ messages in thread
From: Issac Trotts @ 2002-04-13  5:26 UTC (permalink / raw)
  To: 'Gurr, David (MED, self)'; +Cc: caml-list

Thanks, I looked into it.  It looks powerful, yet risky
(being in "its infancy") and intimidating compared to
the simple mechanism for overloading operators in C++.
It would be nice to see something more straightforward.

Issac


> -----Original Message-----
> From: Gurr, David (MED, self) [mailto:David.Gurr@med.ge.com]
> Sent: Friday, April 12, 2002 7:33 PM
> To: Issac Trotts; caml-list@inria.fr
> Subject: RE: [Caml-list] operator overloading
>
>
>
> Try a google search for FOC and ocaml and see if that is not
> a better solution to matrices, etc than overloading. -D
>
> > -----Original Message-----
> > From: Issac Trotts [mailto:ITrotts@IdolMinds.com]
> > Sent: Friday, April 12, 2002 12:08 PM
> > To: caml-list@inria.fr
> > Subject: [Caml-list] operator overloading
> >
> >
> > Looking at the Google results, operator overloading has come up
> > as a frequently discuseed topic.  Still I didn't find anything
> > very useful in the posts that Google brought up.  Can anyone
> > recommend a way to work around OCaml's lack of operator overloading
> > when dealing with matrices, vectors, and spinors?  Is there a
> > way to implement this with ocamlp4?
> >
> > Issac Trotts
> > Programmer
> > Idol Minds
> >
> >
> >
> >
> > -------------------
> > 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
> -------------------
> 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



-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] Operator overloading
@ 2007-03-09 16:40 Robert Fischer
  2007-03-09 17:25 ` Jon Harrop
  0 siblings, 1 reply; 51+ messages in thread
From: Robert Fischer @ 2007-03-09 16:40 UTC (permalink / raw)
  To: caml-list

Exactly.  If I was just going for inference and brevity, I'd still be coding in Perl.

~~ Robert.

-----Original Message-----
From: caml-list-bounces@yquem.inria.fr
[mailto:caml-list-bounces@yquem.inria.fr]On Behalf Of Ian Zimmerman
Sent: Friday, March 09, 2007 10:28 AM
To: Jon Harrop
Cc: caml-list@yquem.inria.fr
Subject: Re: [Caml-list] Operator overloading


> But aren't we all here because we like inference and brevity?

Inference: On condition it is _controlled_.  I.e. seeing operator
<foo> used on a complex type, I need to know I have seen its
definition and satisfied myself that it has the expected semantic
properties.  That's just what functors formalize.

Brevity: There's the pesky tradeoff with some type annotations being
required when you introduce overloading.

_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs


^ permalink raw reply	[flat|nested] 51+ messages in thread
* Operator overloading
@ 2007-03-09  7:36 oleg
  2007-03-09 11:09 ` [Caml-list] " skaller
  0 siblings, 1 reply; 51+ messages in thread
From: oleg @ 2007-03-09  7:36 UTC (permalink / raw)
  To: caml-list


This message illustrates the translation of Haskell98 non-constructor
classes to OCaml, which gives us bounded polymorphism and a sort of
polymorphic recursion in OCaml.

It has to be remarked first that overloading is quite a complex issue:
please see `A Theory of Overloading' by Stuckey and Sulzmann (TOPLAS
2005) for many gory details.  The issue of the type of the plus
operation: 'a->'a->'a or 'a->'b->'c is not an abstract
subtlety. That's why functional dependencies where introduced in
Haskell (and quite often we need local functional dependencies to
resolve overloading). There are three main techniques of implementing
overloading: full inlining (aka C++), dictionary passing, and
the intensional type analysis. The latter is like `switch' and dictionary
passing is like a `vtable'. GHC and Hugs implement dictionary passing,
whereas JHC and Chameleon implement typeclasses via intensional type
analysis. I suspect F# might be doing something like that too, because
CLI might have run-time type tags. 

Non-constructor Haskell 98 classes (that is, overloading over parameter
of the kind *) can be implemented in OCaml in a straightforward way.

We start with a typical Haskell code

class Numb a where
    add :: a -> a -> a
    shw :: a -> String

instance Numb Int where
    add x y = x + y
    shw = show

instance Numb Float where
    add x y = x + y
    shw = show

instance Numb a => Numb [a] where
    add = zipWith add
    shw a = "[" ++ concatMap (\x -> (shw x) ++ " ") a ++ "]"

summ (h:t) = foldl add h t

test1 = shw (add [(1::Int),2,3] [4,5,6])
test2 = shw (summ (add [(1::Int),2,3] [4,5,6]))
test3 = shw (summ [(1.0::Float),2.0,3.0])
test4 = shw (summ [[(1.0::Float),2.0,3.0], [4,5,6], [7,8,9]])

We introduce a class Numb with two methods, for addition and for
showing. The latter is quite handy. The instances for Int and Float
are trivial. The instance of [a] says that if the type of list
elements is in class Numb, the list is in class Numb as well. Note the
definition for the "add" method in that case. It looks recursive: the
body of 'add' invokes 'add' itself, but on a different type.

We then define a function summ. Its inferred type is 
	summ :: (Numb a) => [a] -> a
The function is bounded polymorphic: it works on lists of any type
provided that type is in Numb. The tests test3 and test4 demonstrate
that summ can sum lists and lists of lists, etc.

Here's the OCaml translation:

(* class Numb a *)
type 'a numb = {add: 'a -> 'a -> 'a; shw: 'a -> string};;

(* instance Numb Int *)
let numb_i = {add = (+); shw = string_of_int};;
(* instance Numb Float *)
let numb_f = {add = (+.); shw = string_of_float};;

(* instance Numb a => Numb [a] *)
let numb_l numb_e = {add = List.map2 numb_e.add; 
		     shw = fun a -> 
		       "[" ^ List.fold_right 
			       (fun e z -> " " ^ numb_e.shw e ^ z) a "]"};;

(* we can define a bounded polymorphic function summ *)
let summ numb (h::t) = List.fold_left numb.add h t;;

let test1 = 
  let n = numb_l numb_i in
  n.shw (n.add [1;2;3] [4;5;6]);;

let test2 = 
  let n = numb_l numb_i in
  numb_i.shw (summ numb_i (n.add [1;2;3] [4;5;6]));;

let test3 = 
  numb_f.shw (summ numb_f [1.0;2.0;3.0]);;

let test4 = 
  let n = numb_l numb_f in
  n.shw (summ n [[1.0;2.0;3.0]; [4.0;5.0;6.0]; [7.0;8.0;9.0]]);;


The inferred type of summ in OCaml is
	val summ : 'a numb -> 'a list -> 'a = <fun>
It is instructive to compare it to the Haskell type. The only
difference is in the shape of the arrow: "Numb a =>" vs "'a numb ->".
Instead of the double arrow of Haskell we have the single arrow in
OCaml. The OCaml function summ is likewise bounded polymorphic: it
applies to arrays of any type provided that we have the _evidence_
(the dictionary) that the type is in the class numb. We must pass that
evidence as the first argument of summ. Granted, the burden of procuring
this evidence is on us; Haskell, in contrast, can, most of the time,
build that evidence by itself. As in Haskell, we can sum lists of
numbers and lists of lists of numbers, etc.


Haskell constructor classes (overloading over the parameters of 
higher kinds) do require OCaml functors. The example is a monad. With a
bit of syntactic sugar, the monadic notation and the corresponding
overloading are tolerable in OCaml.

Conversely, OCaml and SML modules (including sealing, generative and
applicative functors and recursive structures) can be emulated in
Haskell typeclasses. Chung-chieh Shan and I wrote a couple of messages
on that topic back in August and September 2004 on the Haskell mailing
list.


John Skaller wrote: ``(Haskell does this little cheat .. it makes
typeclasses very easy to explain to OO people).'' Are you sure about
that? There has been many long and recurring threads on Haskell-Cafe
about typeclasses and OO classes. I think the common advice is _not_
to think of Haskell typeclasses as of OO classes. Ralf Laemmel and I
once wanted to elaborate on the issue of OO in Haskell; we ended up
with a 79-page paper. I guess that shows that OO is never easy.



^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] Operator overloading
@ 2007-03-08 23:20 Robert Fischer
  2007-03-09 10:31 ` Jon Harrop
  0 siblings, 1 reply; 51+ messages in thread
From: Robert Fischer @ 2007-03-08 23:20 UTC (permalink / raw)
  To: caml-list

I didn't realize that existed.  It's not so bad -- it lets me have my
cake and Jon eat it, too.  :D

~~ Robert.

-----Original Message-----
From: caml-list-bounces@yquem.inria.fr
[mailto:caml-list-bounces@yquem.inria.fr]On Behalf Of Fernando Alegre
Sent: Thursday, March 08, 2007 4:25 PM
To: Jon Harrop
Cc: caml-list@yquem.inria.fr
Subject: Re: [Caml-list] Operator overloading


On Thu, Mar 08, 2007 at 07:40:42PM +0000, Jon Harrop wrote:

> For me, operator overloading is about clarity. In the absence of
operator 
> overloading, you cannot regain the lost clarity using modules and
functors.


I often use the poor man's local operator overloading already built into
the core OCaml:

let result =
    let (+) = Vector.add and ( * ) (x:int) (v:Vector.t) =
Vector.scalarmul x v
    in 3 * a + 2 * b

This makes overloading local and explicit, and at the same time makes
expressions clear. I do not miss implicit overloading.

Fernando

_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] Operator overloading
@ 2007-03-08 20:02 Robert Fischer
  2007-03-08 20:15 ` Michael Hicks
                   ` (4 more replies)
  0 siblings, 5 replies; 51+ messages in thread
From: Robert Fischer @ 2007-03-08 20:02 UTC (permalink / raw)
  To: caml-list

> For example, I often define +| for vectors, +|| for matrices, *| for 
> scalar-matrix multiplication, *|| for vector-matrix and *||| for 
> matrix-matrix. I also want to support complex numbers and symbolic 
> expressions and I don't particularly want to remember and document 50 numeric 
> operators, nor explain their existence to my customers...
>
Which is exactly my point.  You should have to document all that, because they are genuinely different operations.  You have these operations, so why shouldn't you document them?  Or, better yet, abstract them and organize them.  By using operator overloading, you're sweeping under the rug genuine complexity -- something that my surprise later developers!

When I see "+", I want to know what that means.  With operator overloading, I don't know.  An IDE might help me out there, but that's just polishing a genuine ding on code readbility and maintainability.  Why should I have to rely on an IDE to make sense of my code?

If I have a typing issue in my code, I want the compiler balk at where the problem is.  The best I can hope for with operator overloading is that the result type is caught through a failure of duck typing shortly down the pipeline -- but that very safety would is undermined if "down the pipeline" also uses lots of operator overloading.

I'm very sure that you can code with operator overloading and be productive.  The person writing the code probably even feels like it's a productivity and readability boon.  But I see maintainability as a big problem here.  As far as I'm concerned, if two things do different things, they should have different names.  You can give them funny names like "+|", but it should still be different names.

~~ Robert.

-----Original Message-----
From: caml-list-bounces@yquem.inria.fr
[mailto:caml-list-bounces@yquem.inria.fr]On Behalf Of Jon Harrop
Sent: Thursday, March 08, 2007 1:41 PM
To: caml-list@yquem.inria.fr
Subject: Re: [Caml-list] Operator overloading


On Thursday 08 March 2007 17:54, Brian Hurt wrote:
> Roland Zumkeller wrote:
> > Wasn't there a more or less good reason for OCaml *not* to support
> > operator overloading?
>
> Yes.  Ocaml has modules and functors.  IMHO, any time you thing "boy,
> it'd be really nice to use operator overloading here", you should use a
> module and a functor instead.
> ...

For me, operator overloading is about clarity. In the absence of operator 
overloading, you cannot regain the lost clarity using modules and functors.

This is one of the two things I missed when I moved from C++ to OCaml: 
operator overloading and template metaprogramming for low-dimensional vector 
and matrix operations. The latter can be addressed by autogenerating code. 
The former cannot be addressed in the current OCaml.

For example, I often define +| for vectors, +|| for matrices, *| for 
scalar-matrix multiplication, *|| for vector-matrix and *||| for 
matrix-matrix. I also want to support complex numbers and symbolic 
expressions and I don't particularly want to remember and document 50 numeric 
operators, nor explain their existence to my customers and I certainly don't 
appreciate reading expressions written in this syntax.

-- 
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
OCaml for Scientists
http://www.ffconsultancy.com/products/ocaml_for_scientists

_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] F#
@ 2007-03-08 14:41 Robert Fischer
  2007-03-08 17:30 ` Roland Zumkeller
  0 siblings, 1 reply; 51+ messages in thread
From: Robert Fischer @ 2007-03-08 14:41 UTC (permalink / raw)
  To: caml-list

> However, operator overloading (i.e. overloading symbols) makes numerical code 
> so much easier to read that it is worth sacrificing some inference for it.
>

Unless, of course, you like to know what it is you're actually doing.

It's bad enough trying to figure out what "+" means in an overloaded environment with nominal typing.  With duck typing, it's a mess, and it's a mess that both you and the compiler have to work hard to figure out.

I highly suggest checking out the Programmer-to-Programmer book on C# and their conversation about operator overloading.  They do a nice job documenting just why it's such a dangerous tool in the toolbox.

~~ Robert.


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] operator overloading
@ 2002-04-15 17:05 Issac Trotts
  0 siblings, 0 replies; 51+ messages in thread
From: Issac Trotts @ 2002-04-15 17:05 UTC (permalink / raw)
  To: 'Jun P.FURUSE'; +Cc: Caml-List (E-mail)

Hello,

> > Looking at the Google results, operator overloading has come up
> > as a frequently discussed topic.  Still I didn't find anything
> > very useful in the posts that Google brought up.  Can anyone
> > recommend a way to work around OCaml's lack of operator overloading
> > when dealing with matrices, vectors, and spinors?  Is there a
> > way to implement this with ocamlp4?
>
> As already someone has mentioned, you can try G'Caml: O'Caml with
> Extensional Polymorphism Extension. You can overload values
> over identifiers (including constants and operators),
> in the style of the pattern matching on types. Its experimental
> implementation is found at
>
>    http://pauillac.inria.fr/~furuse/generics/
>
> Regards,
> --------------------------------------------------------------
> ---------
> Jun P. Furuse 					
> Jun.Furuse@inria.fr
>

This looks like a very useful variant of OCaml.  Are there any plans
to merge it with the main OCaml source after the bugs are worked out?

Cheers,
Issac Trotts
Programmer
Idol Minds




-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] operator overloading
@ 2002-04-14  4:15 Issac Trotts
  0 siblings, 0 replies; 51+ messages in thread
From: Issac Trotts @ 2002-04-14  4:15 UTC (permalink / raw)
  To: 'forsyth@caldo.demon.co.uk'; +Cc: Caml-List (E-mail)

I would agree that C++'s operator overloading is a little warty,
but it's easy enough use.

Maybe it would be possible to extend OCaml's odd idea of using
different looking operators for different types.  For instance,
3D vector operations could be done like this:

	a +^ b (* add *)
	a -^ b (* subtract *)
	a .^ b (* dot product *)
	a ^^ b (* cross product, or maybe wedge product *)

Matrix operations could be done with #'s after the operators.
Spinor ops could be suffixed with @s, etc.

Issac


> -----Original Message-----
> From: forsyth@caldo.demon.co.uk [mailto:forsyth@caldo.demon.co.uk]
> Sent: Saturday, April 13, 2002 2:44 AM
> To: caml-list@inria.fr
> Subject: RE: [Caml-list] operator overloading
>
>
> >>compared to
> >>the simple mechanism for overloading operators in C++.
> >>It would be nice to see something more straightforward.
>
> i think it's the first time i've seen operator overloading in
> C++ described
> as a `simple mechanism'.
>
> -------------------
> 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



-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] operator overloading
@ 2002-04-13  8:43 forsyth
  0 siblings, 0 replies; 51+ messages in thread
From: forsyth @ 2002-04-13  8:43 UTC (permalink / raw)
  To: caml-list

>>compared to
>>the simple mechanism for overloading operators in C++.
>>It would be nice to see something more straightforward.

i think it's the first time i've seen operator overloading in C++ described
as a `simple mechanism'.

-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread
* RE: [Caml-list] operator overloading
@ 2002-04-13  1:32 Gurr, David (MED, self)
  0 siblings, 0 replies; 51+ messages in thread
From: Gurr, David (MED, self) @ 2002-04-13  1:32 UTC (permalink / raw)
  To: Issac Trotts, caml-list


Try a google search for FOC and ocaml and see if that is not
a better solution to matrices, etc than overloading. -D

> -----Original Message-----
> From: Issac Trotts [mailto:ITrotts@IdolMinds.com]
> Sent: Friday, April 12, 2002 12:08 PM
> To: caml-list@inria.fr
> Subject: [Caml-list] operator overloading
> 
> 
> Looking at the Google results, operator overloading has come up 
> as a frequently discuseed topic.  Still I didn't find anything 
> very useful in the posts that Google brought up.  Can anyone 
> recommend a way to work around OCaml's lack of operator overloading
> when dealing with matrices, vectors, and spinors?  Is there a 
> way to implement this with ocamlp4?
> 
> Issac Trotts 
> Programmer
> Idol Minds
> 
> 
> 
> 
> -------------------
> 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
-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread
* [Caml-list] operator overloading
@ 2002-04-12 19:08 Issac Trotts
  2002-04-13  8:48 ` William Chesters
                   ` (3 more replies)
  0 siblings, 4 replies; 51+ messages in thread
From: Issac Trotts @ 2002-04-12 19:08 UTC (permalink / raw)
  To: caml-list

Looking at the Google results, operator overloading has come up
as a frequently discuseed topic.  Still I didn't find anything
very useful in the posts that Google brought up.  Can anyone
recommend a way to work around OCaml's lack of operator overloading
when dealing with matrices, vectors, and spinors?  Is there a
way to implement this with ocamlp4?

Issac Trotts
Programmer
Idol Minds




-------------------
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


^ permalink raw reply	[flat|nested] 51+ messages in thread

end of thread, other threads:[~2007-03-10  5:33 UTC | newest]

Thread overview: 51+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2002-04-13  5:26 [Caml-list] operator overloading Issac Trotts
  -- strict thread matches above, loose matches on Subject: below --
2007-03-09 16:40 [Caml-list] Operator overloading Robert Fischer
2007-03-09 17:25 ` Jon Harrop
2007-03-09  7:36 oleg
2007-03-09 11:09 ` [Caml-list] " skaller
2007-03-09 13:52   ` Andreas Rossberg
2007-03-09 15:07     ` skaller
2007-03-09 16:28       ` Andreas Rossberg
2007-03-10  3:13         ` skaller
2007-03-08 23:20 Robert Fischer
2007-03-09 10:31 ` Jon Harrop
2007-03-08 20:02 Robert Fischer
2007-03-08 20:15 ` Michael Hicks
2007-03-08 20:50   ` Brian Hurt
2007-03-08 21:05 ` Tom
2007-03-08 21:31   ` Brian Hurt
2007-03-08 22:09     ` Michael Vanier
2007-03-08 22:34     ` Till Varoquaux
2007-03-09 16:02       ` Brian Hurt
2007-03-10  3:23         ` skaller
2007-03-08 22:14   ` Ian Zimmerman
2007-03-09 10:29     ` Jon Harrop
2007-03-09 16:28       ` Ian Zimmerman
2007-03-08 23:51 ` skaller
2007-03-09  7:23   ` Tom
2007-03-09  9:24     ` skaller
2007-03-09  9:32       ` Tom
2007-03-09 10:00         ` skaller
2007-03-09 10:14         ` Jon Harrop
2007-03-09 10:38   ` Jon Harrop
2007-03-09 10:20 ` Jon Harrop
2007-03-09 12:08 ` Andrej Bauer
2007-03-09 12:48   ` Jacques Carette
2007-03-09 13:24   ` Andreas Rossberg
2007-03-10  5:08   ` Daniel Andor
2007-03-10  5:33     ` David Thomas
2007-03-08 14:41 [Caml-list] F# Robert Fischer
2007-03-08 17:30 ` Roland Zumkeller
2007-03-08 17:54   ` Brian Hurt
2007-03-08 19:40     ` [Caml-list] Operator overloading Jon Harrop
2007-03-08 20:44       ` Brian Hurt
2007-03-08 22:24       ` Fernando Alegre
2002-04-15 17:05 [Caml-list] operator overloading Issac Trotts
2002-04-14  4:15 Issac Trotts
2002-04-13  8:43 forsyth
2002-04-13  1:32 Gurr, David (MED, self)
2002-04-12 19:08 Issac Trotts
2002-04-13  8:48 ` William Chesters
2002-04-13 13:58   ` Brian Rogoff
2002-04-13 15:31     ` William Chesters
2002-04-14  3:10       ` Brian Rogoff
2002-04-13  9:00 ` Daniel de Rauglaudre
2002-04-13 21:35 ` Johan Georg Granström
2002-04-14  1:50   ` Jacques Garrigue
2002-04-15 16:22 ` Jun P.FURUSE

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).