dsimcha wrote:
This discussion originated in the T[new] thread, but I think it deserves its own
thread.

== Quote from Denis Koroskin ([email protected])'s article
An Array!(T) is really just a different name to a T[new]. You'll have the
same problem explaining difference between Array!(T) and T[].
But you are also creating a nightmare for CTFE. Since you can't use "a ~=
b;" anymore, you'll have to use "a = a ~ b;" which *always* allocates. Not
only it is syntactically less pleasant, this way you render this function
useless at run-time - who in the sane mind will use such an inefficient
stuff?

Maybe what we need is a version(ctfe) statement.  Stuff inside such a block 
would
be executed only if a function is being compile time evaluated.  When code is
generated for runtime evaluation the else block would be used.  This would allow
problems like this to be solved in a well-encapsulated way.  Example:

uint[] findPrimes(uint maxPrime) {
    version(ctfe) {
        uint[] ret;
    } else {
        ArrayBuilder!uint ret;
    }

    foreach(i; 0..maxPrime) {
        if(!isPrime(i)) {
             continue;
        }

        version(ctfe) {
            ret = ret ~ i;
        } else {
            ret ~= i;
        }
    }
}

Given that CTFE will likely never support everything that is supported at 
runtime,
this will likely make it much more useful.

version(ctfe) would be helpful in many other situations (e.g. asm-optimized routines etc.)

I thought more about it and realized that ~= can be still implemented for arrays if the GC cooperates.

For relatively large chunks of memory, the GC keeps a control block. We could add a member size_t requestedSize that keeps the size that was requested with an allocation/reallocation call. The GC can take initiative in overallocating memory and expose primitives such as requestedSize (how much did the program ask for?) and capacity (how much is really allocated?). With that API, it is possible to implement ~= efficiently.


Andrei

Reply via email to