I tried this on a whim and it appears to work:

auto static_array(T, size_t data_size)()
{
    T[data_size] data;
    return data;
}

void main() {
    import std.stdio: writeln;
    import std.traits: isStaticArray;

    auto data = static_array!(int, 5)(3);
    writeln(data);
    static assert(__traits(isStaticArray, data));

    auto data_longer = static_array!(int, 6)(2);
    writeln(data_longer);
    static assert(__traits(isStaticArray, data_longer));
}


Is this for real, static arrays at runtime without manually allocating memory ? Is this legitimate or should I expect problems ?

On Sunday, 3 February 2019 at 16:33:48 UTC, Emil wrote:
> I tried this on a whim and it appears to work:
>
> auto static_array(T, size_t data_size)()
> {
>     T[data_size] data;
>     return data;
> }

This is actually already in the standard library:

https://dlang.org/phobos/std_array.html#staticArray

On Sunday, 3 February 2019 at 16:36:30 UTC, Paul Backus wrote:
...
> This is actually already in the standard library:
>
> https://dlang.org/phobos/std_array.html#staticArray

thank you

either I already read that and forgot or finally I'm starting to get the feel of the language :)

On Sunday, 3 February 2019 at 16:33:48 UTC, Emil wrote:
>
> Is this for real, static arrays at runtime without manually allocating memory ? Is this legitimate or should I expect problems ?

Static arrays are always allocated at run-time. It's the size of the array that must be known at compile-time (in this case via a template parameter).

What's the advantage (or the essential difference) of
    auto data = static_array!(int, 5);
instead of
    int[5] data;
? Just asking ;) but it's good to play.

What does not compile on my end are the run-time parameters (3) and (2)...?

On Monday, 4 February 2019 at 16:08:38 UTC, XavierAP wrote:
> Static arrays are always allocated at run-time. It's the size of the array that must be known at compile-time (in this case via a template parameter).
>
> What's the advantage (or the essential difference) of
>     auto data = static_array!(int, 5);
> instead of
>     int[5] data;
> ? Just asking ;) but it's good to play.
>
> What does not compile on my end are the run-time parameters (3) and (2)...?

you are correct ...

24 hours of being very satisfied with myself were good, but also good thing I did not quit and start looking for a D job


Can std.array.staticArray build static arrays with size known only at run time ? Now that I am not overcome with enthousiasm it looks like it too needs to know the size.

On Mon, Feb 04, 2019 at 07:14:38PM +0000, Emil via Digitalmars-d-learn wrote: [...]
> Can std.array.staticArray build static arrays with size known only at run time ? Now that I am not overcome with enthousiasm it looks like it too needs to know the size.

That's not possible, because the size of a static array is part of its type, meaning it must be known at compile-time.

Perhaps what you're looking for is alloca (and possibly a slice over
that)?


T

-- 
In a world without fences, who needs Windows and Gates? -- Christian Surchi

On Monday, 4 February 2019 at 19:14:38 UTC, Emil wrote:
>
> Can std.array.staticArray build static arrays with size known only at run time ? Now that I am not overcome with enthousiasm it looks like it too needs to know the size.

A static array's size must be known (or computed) at compile time, by definition... There can be no exception; staticArray() gets or infers the size from its template/compile-time arguments.

For one, the trivial example on dlang.org/phobos
    auto a = [0, 1].staticArray;
    static assert(is(typeof(a) == int[2]));
is equivalent to
    int[2] a = [0, 1];
    static assert(is(typeof(a) == int[2]));
Is it better? Depends on.....? No it really isn't...

However one of the possibilities of D is the ability to generate and execute quite some code at compile time by means of meta-programming; and I guess here's where staticArray() may end up being useful enough to have merited introduction into the std library; not for trivial uses where a straightforward T[n] declaration is preferable, being possible...

If there is something you want to solve in a program of yours, there may be another way, as H.S. Teoh suggests. If you're just trying out stuff it's also fine, :) there's still more.

On Monday, 4 February 2019 at 22:48:10 UTC, XavierAP wrote:
...
> If there is something you want to solve in a program of yours, there may be another way, as H.S. Teoh suggests. If you're just trying out stuff it's also fine, :) there's still more.

Since August last year I try to read or write a bit of D code every day. I'm still trying out stuff and going through the books.

In this case I was way too excited about passing both types and data to a template and having it compile the first time I tried, and jumped to conclusions.

Thank you for pointing where my confusion was.

On Monday, 4 February 2019 at 22:48:10 UTC, XavierAP wrote:
> However one of the possibilities of D is the ability to generate and execute quite some code at compile time by means of meta-programming; and I guess here's where staticArray() may end up being useful enough to have merited introduction into the std library; not for trivial uses where a straightforward T[n] declaration is preferable, being possible...

The main benefit of staticArray is that it allows the length of the array to be inferred from the initializer (like in C).