From: Frank Bergemann on
reading about boost::proto i get back to the question of trading
compile time efforts for run time efficiency.
Unfortunately so far i didn't find a tutorial/example to hit the point
here. In concrete i'd like to know, how run-time data go into the
processing. I guess they have to move into what's names the "context" in
tutorial of boost::proto(?)
And the compiler can create a data-path structure for the context data -
maybe pretty much like e.g. the butterfly-diagram for FFT-Calculation.
Can anybody refer some good example for such?

Another issue raising for studying boost::proto.
Does it get us more closer to Compile-Time-Function-Evaluation (CTFE)
for C++?
So far templates is "programming with types".
And we need to to use type-wrapper for numerics (e.g.)
AFAIK it only supports calculations with built-in types and some basic
operations for those. (e.g. there is no support for doubles and no
support for thinks like sin(x)).
I wonder what we would get, if we had the option for multi-level
compilation respectively recursive compilation. Like (terminated)
recursion is used with templates in one compilation "process".
So why not allowing (recursive) sub-compilations?
What's the problem in providing such for the compilers (like gcc)?
I think it would be amazing options to have recursive code construction.
It might set up another borderline shifting - this time between
compilers and interpreters.


[ See for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]