Arrays, garbage collection

[Foo via Digitalmars-d]

On Friday, 30 January 2015 at 01:08:31 UTC, bearophile wrote:
> The D type inference for array literals is now more flexible:
>
> void main() {
>     auto[$][$] m1 = [[1, 2], [3, 4], [5, 6]];
>     pragma(msg, typeof(m1));  // int[2][3]
>     const auto[string] aa1 = ["red": 1, "blue": 2];
>     pragma(msg, typeof(aa1)); // const(int)[string]
> }
>
>
> It helps avoid bugs like:
>
> int[5] a = [1,2,4,5];
> void main() {}
>
> And it makes the usage of value arrays (fixed size arrays) more 
> handy. We need to minimize the work that the garbage collector 
> has to do. Value arrays help in this. So making value arrays 
> more handy and natural to use is good (regardless how the 
> current Phobos hates them).
>
> - - - - - - - - -
>
> What's missing is a handy and compiler-efficient syntax to 
> create value array literals. Some persons have proposed the 
> "[]s" syntax:
>
>
> void main() {
>     // Some imports here.
>     foo([[1, 2]s, [3, 4]]s);
>     auto t1 = tuple([1, 2]s, "red");
>     auto aa1 = ["key": [1, 2]s];
>     auto pairs = 10.iota.map!(i => [i, i + 10]s);
> }
>
>
> To do those same things without the []s syntax you have to 
> write longer code.

----
@nogc
@safe
T[n] s(T = Args[0], size_t n = Args.length, Args...)(auto ref 
Args args) pure nothrow {
	return [args];
}

@nogc
@safe
T[n] s(T, size_t n)(auto ref T[n] values) pure nothrow {
	return values;
}
	
void main() {
	pragma(msg, typeof(s(1, 2, 3)));
	pragma(msg, typeof([1, 2, 3].s));
}
----

Compilation output:
int[3]
int[3]

You only have to type a dot between the array and the 's'.
Because of pure and nothrow and the low cost of the function call 
even such a lousy thing like the DMD optimizer should be capable 
of inlining such a function every time.