Version française
Home     About     Download     Resources     Contact us    
Browse thread
Re: [Caml-list] productivity improvement
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jeffrey Palmer <jeffrey.palmer@a...>
Subject: Re: [Caml-list] Re: Camlp4 optimizations (was: productivity improvement)
On Thursday 17 October 2002 4:19 pm, Brian Hurt wrote:
> I will say- there is a way to get both the ease of development of
> operator overloading *and* the performance of BLAS.  Make matrices
> first class types known to the compiler, like ints, floats, and
> strings (vectors can be considered m-by-1 matrices).  Now the
> compiler knows what substitutions are legal or not- it can easily
> replace a = b + c + d; with a = b; a += c; a += d;, or even a = d; a
> += c; a += b; if it feels like it.
>

There are alternatives to adding these as primitive types to the 
language. In the case of C++, the concept of template metaprogramming 
(basically a weakened macro system) has shown that it's possible to 
generate numeric code on par with Fortran by rewriting expressions to 
avoid pairwise evaluation. See:

http://osl.iu.edu/~tveldhui/papers/iscope97/index.html
http://osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html
http://osl.iu.edu/~tveldhui/papers/Template-Metaprograms/meta-art.html

for the background and some examples of this approach.

However, the (obvious) problem with this approach, from a C++ 
perspective, is that it is not supported by the language. This stuff 
was basically "discovered", rather than designed, and if you've ever 
tried to use these techniques, this becomes VERY clear. The syntax is a 
disaster. An in-language mechanism for this type of macro expansion (a 
la lisp/scheme macros) would simplify this immensely.

Is this approach implementable in ocaml? The C++ template mechanism has 
complete access to the C++ type system, which makes it significantly 
more useful than the standard preprocessor. I seem to remember an 
earlier posting (today) indicating that this type information isn't 
available in ocamlp4.

Does anyone know of any strongly-typed languages where this type of 
macro expansion/partial evaluation is available?  (I seem to remember 
GHC providing a hook mechanism for term rewriting during optimization, 
but I don't think that's quite the same...)

Cheers,

	- j

(Actually, now that I think about it, I recall someone on one of the C++ 
newsgroups discussing the possibility of using a functional language 
for the template language, since it seems like most of the interesting 
things you can do with templates are functional in nature.)


-- 
The river is moving.
The blackbird must be flying.

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