Jeffrey Palmer wrote:
> On Thursday 17 October 2002 6:55 pm, Alessandro Baretta wrote:
> 
> 
> Hmm. I have two observations:
> 
> 1) You can't "use" templates without instantiating them, so although 
> you're right - template type checking is deferred to instantiation, 
> this is by design (a pain, I agree).

It's more than a pain. John Max Skaller acutely pointed out 
that templates have "no semantics". The semantics of a 
template depends on the parameter(s) with which it is 
instantiated, and in a very bizzarre way. Code which 
compiles and is correct with well-behaved parameters--the 
STL, for example--becomes incorrect, won't compile, or will 
miserably die at runtime with a segfault, if it is 
instantiated with a parameter class redefining the basic 
operations--equality, assignment, copy constructor, etc--in 
a such a way as to violate the assumptions explicitly or 
implicitly made by the template designer. Such errors are 
not revealed when the template is written and "compiled". 
They are revealed at best at template instantiation time, 
and possibly at runtime.

Caml functors, on the other hand, are statically type 
checked at compile time. Once and for all. If they compile, 
they're correct. And that's it.

> 2) Template code, during instantiation, has access to the type system. 
> You can write conditional template code that will be instantiated only 
> if A is a subclass of B, etc. Although the mechanisms used to do this 
> are obtuse, it is possible.

I did not know such constructs exist. I knew about RTTI. Now 
I discover C++ has a TITI--Template Instantiation Type Id. I 
take it to mean that the compiler allows you to write 
manually the checks that it ought to perform by himself: 
namely, that the type parameter has the methods that you 
need to invoke on it. Can you point me to any reference I 
could look into on his point?

>>The golden rule of C++: Use classes, not templates.
> 
> 
> Interesting. I'd say the opinion has shifted from not using templates to 
> using them for almost everything. It seems that, since the introduction 
> of the C++ standard library, everyone is building template libraries. 
> It's almost as though people have decided that "virtual" is a dirty 
> word. ;)

It's just a matter of taste, like any golden rule. The 
predominant trend seems to be embodied by Java: subtyping 
polymorphism and RTTI, which in Java goes with the name 
"reflection".

>>Once Camlp4 has built the syntax
>>tree you can apply any program transformation you care to,
>>in order to optimize your program.
> 
> 
> I really have to make some time to play with that thing - it really 
> sounds amazing.

Not really. TANSTAAFL. You want to optimize your 
code--explicitly unroll loops, rewrite matrix manipulation 
code, and whatnot. Go on, but you better prove that what 
you're doing is correct. I am not a big fan of Hoare's 
method, but I'd definitely use it to make sure the resulting 
compiler is semantically equivalent to the vanilla ocamlc. 
Besides, it's not miraculous, what you end up with is always 
ocaml code, albeit in an abstract form. As DdR pointed out, 
Camlp4 can generate nothing that you cannot code by hand.

> Oh, and in response to my own earlier question regarding partial 
> evaluation and strongly-typed languages, I noticed a post elsewhere on 
> the list to a very interesting site:
> 
> http://www.cs.rice.edu/~taha/MetaOCaml/
> 
> Enjoy!
> 
> 	- j
> 

You too!

Alex

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