compile-time explicitness

[Steven Schveighoffer]

On Fri, 23 Sep 2011 14:47:32 -0400, Gor F. Gyolchanyan  
<gor.f.gyolchanyan at gmail.com> wrote:

> Of course, if the entire D gets CTFE-able, the __ctfe will be completely  
> useless.
> But i can't see that coming for a long time.

Well, anywhere that it makes sense, it should be CTFE-able.

For example to!string(int) should be CTFE-able, as well as to!int(string)

I think a really cool CTFE feature would be if sort could be used in  
compile time.  Imagine writing a lookup table in whatever order you want,  
then just using:

enum lookupTable = sorted(lookupData);

I can think of a few places that would have been useful in my past.

Places where __ctfe is useful are functions that depend on opaque runtime  
functions.  Then you can write alternatives.  Again, I'll refer you to  
std.array.Appender.

> Most of the major programming
> problems are best solved with classes and that's where CTFE stops.

I'm not sure everybody agrees on that.  Classes are good for certain  
things, and horrible for others.

> About templates:
>
> void unpackIntoFunction(alias arrayOfVariants, alias func)()
> {
>    // you can't generate the necessary mixin strings right here, because  
> it won't
> be compile-time.
>    // you need to create a separate function, that returns the required  
> string to
> be mixed in.
>    mixin(whatIJustGenerated);
> }

enum + static if signifies compile time.  If you want to use the  
compile-time constructs, you can build it at compile-time.  Otherwise, you  
can either use eponymous templates (functional style) or CTFE-able  
functions (imperative style).

A more complete example will allow better explanation.

-Steve