On Monday, October 01, 2012 19:46:16 Tommi wrote: > On Monday, 1 October 2012 at 08:04:49 UTC, Jonathan M Davis wrote: > > And you _can't_ determine ahead of time which functions can be > > safely executed at compile time either, because that's an > > instance of the halting problem. > > I don't understand (I did read what "halting problem" means just > now, but I still don't understand). If there was no __ctfe > variable, and thus a guarantee that all functions do the same > thing at compile-time and run-time,
__ctfe exists purely so that you can provide an alternate implementation which works at compile time when the normal implementation doesn't (since CTFE _is_ more restrictive in what it allows than running a function at runtime is). > couldn't the compiler just > try aggressively to execute all function calls at compile-time? So, the compiler is supposed to run every function at compile time and then back up if it a function doesn't work? It can't even always know for sure when a function doesn't work (e.g. infinite loop). This would absolutely _tank_ compilation times. Most functions _can't_ be run at compile time simply because of how they're called, and the compiler can't necessarily know that unless it does full flow analysis if not outright _runs_ every function, which would be _incredibly_ expensive. > If not a compiler flag, then it could be a function attribute. > Just like c++ function attribute constexpr, which guarantees that > the function executes at compile time given you provide it with > compile-time evaluable arguments (and there are limitations to > what the function can do). Why wouldn't this attribute be > possible with D? CTFE was specifically designed with the idea that you would not need to mark functions as CTFEable. You can call _any_ function at compile time. Some will fail, because they're doing things that CTFE won't allow, but that's quickly caught, because it happens at compile time. It completely avoids needing to mark functions as CTFEable all over the place (which would generally mean that functions wouldn't be CTFEable, because people would frequently not mark them as CTFEable). constexpr is in direct conflict with that design goal. And if you want a function to be executed at compile time, you assign its result to an enum or static variable. Done. It's easy and straightforward. I really don't understand why this is an issue at all. - Jonathan M Davis
