RFC: scope and borrowing

[bearophile via Digitalmars-d]

Marco Leise:

> The amount of possible use-cases you listed for this extension
> is staggering.

With scope management in code like this:


import std.stdio, std.algorithm;
int foo(in int[] a) {
     return sum([0, 1] ~ a[1 .. $ - 2] ~ 0 ~
                [a[$ - 1] + 1, a[$ - 1] + 2]);
}
void main() {
     int[5] b = [10, 20, 30, 40, 50];
     b.foo.writeln;
}


The compiler in theory could lower the code to something like 
this, removing all heap allocations for the array literals and 
the concatenations, allowing 'foo' to be annotated with @nogc (I 
don't know if Rust is able to do this, I presume it can):


import std.stdio, std.algorithm, core.stdc.stdlib;
T foo(T)(in T[] a) @nogc {
     immutable size_t L = 2 + a.length - 3 + 1 + 2;
     auto ptr = alloca(T.sizeof * L);
     if (ptr == null)
         exit(1); // Or throw a stack overflow error.
     T[] b = (cast(T*)ptr)[0 .. L];
     b[0] = 0;
     b[1] = 1;
     b[2 .. $ - 3] = a[1 .. $ - 2];
     b[$ - 3] = 0;
     b[$ - 2] = a[$ - 1] + 1;
     b[$ - 1] = a[$ - 1] + 2;
     return sum(b);

}
void main() {
     int[5] c = [10, 20, 30, 40, 50];
     c.foo.writeln;
}


But in some cases you don't want those arrays to be allocated on 
the stack because you know they are very large. So the [...]s 
array literal syntax becomes useful again:

import std.stdio, std.algorithm;
int foo(const scope int[] a) {
     return sum([0, 1]s ~ a[1 .. $ - 2] ~ 0 ~
                [a[$ - 1] + 1, a[$ - 1] + 2]s);
}


But this is still not enough, because even if those parts are all 
safely stack-allocated, the result of the concatenation is still 
not stack-allocated.


This could be enough:

import std.stdio, std.algorithm;
int foo(const scope int[] a) @nogc {
     auto[$] a2 = [0, 1]s ~ a[1 .. $ - 2] ~ 0 ~
                  [a[$ - 1] + 1, a[$ - 1] + 2]s;
     return sum(a2[]);
}

Bye,
bearophile