Re: More useful fixed-size array literals

[bearophile via Digitalmars-d]

Benjamin Thaut:

give "scope" a meaning for function arguments other then 
lambdas E.g:

size_t count(scope int[] heystack, scope int[] needle);

Now the compiler can allocate the literal [1, 5] on the stack 
without any special syntax because it knows that the array 
literal will not be escaped.


With your suggestion this code should be accepted:

int foo(scope int[] items) @nogc {
    int total = 0;
    foreach (immutable x; items)
        total += x;
    return total;
}
void main() @nogc {
    assert(foo([1, 5, 3, 1, 5, 1, 5]) == 21);
}



While this can't be accepted because 'items' escapes the body of 
'foo', so 'scope' forbids some valid code:

import std.algorithm: sum;
int foo(scope int[] items) @nogc {
    return foo.sum;
}
void main() @nogc {
    assert(foo([1, 5, 3, 1, 5, 1, 5]) == 21);
}



The []s syntax moves the control to the calling point, allowing 
more valid code to compile:

import std.algorithm: sum;
int foo(int[] items) @nogc {
    return foo.sum;
}
void main() @nogc {
    assert(foo([1, 5, 3, 1, 5, 1, 5]s) == 21);
}



A disadvantage of the []s syntax is that it's less safe than 
scope:

int[] global;
void foo() @nogc {
    bar([1, 5, 3, 1, 5, 1, 5]s);
}
void bar(int[] b) @nogc {
    global = b;
}
void main() {
    import std.stdio;
    foo();
    writeln(global);
}



But that usage of []s is not much worse than this currently 
accepted code, the difference is that the []s syntax makes this 
problem a bit less visible:

int[] global;
void foo() @nogc {
    int[7] a = [1, 5, 3, 1, 5, 1, 5];
    bar(a); // Implicit slicing.
}
void bar(int[] b) @nogc {
    global = b;
}
void main() {
    import std.stdio;
    foo();
    writeln(global);
}


(I think Jonathan M Davis suggested to disallow such implicit 
slicing, and require a "bar(a[]);".)


A possible way to increase the number of functions allowed by 
'scope' is to allow a reference to escape if it goes into another 
'scope':

int sum(scope int[] items) @nogc {
    int total = 0;
    foreach (immutable x; items)
        total += x;
    return total;
}
int foo(scope int[] items) @nogc {
    return sum(items); // Allowed.
}
void main() @nogc {
    assert(foo([1, 5, 3, 1, 5, 1, 5]) == 21); // Allowed.
}



(The problem with Scott Meyers' suggestion in the "The Last Thing 
D Needs" keynote is that to design a language/library feature 
that takes in account every other language/library part, you need 
a mind significantly larger than the average human one :-) ).

Bye,
bearophile