Compile-time vs. compile-time

[H. S. Teoh]

On Wed, Jan 03, 2018 at 02:44:21PM +0100, ag0aep6g via Digitalmars-d wrote:
> On 01/03/2018 02:51 AM, H. S. Teoh wrote:
> > 	https://wiki.dlang.org/User:Quickfur/Compile-time_vs._compile-time#But_what_of_runtime_performance.3F
> > 
> > object.destroy! :-P
> 
> In the CTFE section, you explain that it came from constant folding,
> but you don't point out how the two are different. After reading the
> section, a newbie might think that the term "CTFE" is for when
> constant folding evaluates function calls. But that's not what we mean
> by "CTFE".
> 
> What's missing is that CTFE is forced/guaranteed. It's not an
> optimization.  When we say "CTFE", we mean the cases where compilation
> fails if the expression cannot be evaluated.

I wouldn't say that CTFE means that it is forced/guaranteed. But you're
right that it could be confusing the way I described it.  I added a
section to clarify that usually the compiler would not use CTFE to
constant-fold complex expressions, unless the value is required at
compile-time.


> I doesn't help that the `i` variables in the examples are (seemingly)
> globals, but you also talk about putting them in a "busy inner loop".
> If I just copy the code as it is, `i` is a global and I get actual
> CTFE. If I put `i` in a loop, it's a local and it's up to the compiler
> if it does non-CTFE constant folding.

Are you sure that's non-CTFE?  Isn't standard constant folding a part of
CTFE?  Anyway, the new section should clear up the confusion.


> Also, you mistyped Stefan Koch's name.

Fixed, thanks!


T

-- 
Try to keep an open mind, but not so open your brain falls out. -- theboz