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