Motivation for compile time function execution

[Sean Kelly]

Walter Bright wrote:
> The sqrt() example I gave is cute, but not a very interesting reason for 
> doing compile time function execution. So what's the real reason?
> 
> A while back, Eric Anderton and Don Clugston showed how one could use 
> template metaprogramming techniques to do, for example compile time 
> regular expressions. It was a marvelous technical demonstration, and 
> showed that essentially any computation could be done, using templates, 
> at compile time.
> 
> There were some serious problems, though:
> 
> 1) They are hard and unintuitive to write (for those not comfortable 
> with functional programming, which is most of us).
> 
> 2) The result looks awful - templates are just syntactically unsuited to 
> this, even though they're a lot easier on the eye than C++ template 
> metaprograms.
> 
> 3) This is off-putting enough that some question even having such 
> facilities in the language, as it results in impenetrable code 
> unmaintainable by joe coders.
> 
> 4) While theoretically capable of any computation, such template 
> metaprogramming had severe practical limitations. Every step of every 
> computation required generating a unique template. This naturally is 
> incredibly slow and memory consumptive (C++ metaprogramming is notorious 
> for taking all night to do a build). Even worse, if you're going to use 
> string templates to parse, say, a 1000 character DSL, the template name 
> generated must include its arguments, so that template identifier will 
> be 1000 characters long. Then, it slices off the first character, and 
> generates another template for the rest (999), then 998, then 997, etc., 
> until 1000 templates are generated averaging 500 characters long. It 
> doesn't take much of that before the whole thing collapses.
> 
> 5) In casting about for a solution, the compile time regex came up 
> again. This was still strongly disliked.
> 
> 6) I promised to try and make template metaprogramming less obtuse, and 
> what better way to do that than to obsolete a whole class of templates, 
> replacing them with ordinary functions?

I think this is a fantastic feature.  It uses plain old D syntax and 
offers all the computational power of templates.  Will this work for 
template functions that follow the rules as well?  Also, is there any 
way to test whether a function is being executed at run time?  Perhaps 
by placing a pragma(msg) inside the function body?


Sean