Re: Fixed size array initialization
On Sunday, 11 February 2018 at 14:06:32 UTC, rjframe wrote:
On Sat, 10 Feb 2018 10:55:30 +, rumbu wrote:
If you separate initialization to a static this, you'll get a
compile error:
```
immutable uint256[78] pow10_256;
static this() {
// Error: mismatched array lengths, 78 and 2
pow10_256 = [
uint256(1UL),
uint256(10UL)
];
}
```
Yes, this was in fact the idea of
https://github.com/dlang/phobos/pull/4936
Didn't like it, sorry.
Or if you know that no element should be the object's init
value, you could do a static foreach to validate that at
compile-time.
Nice idea too, but this will significantly increase compilation
time.
You could also generate the elements at compile-time (this
could use some improvement, and should be generalized so a
single function can generate fillers for your other arrays as
well):
```
immutable uint256[78] pow10_256;
static this() {
// Uncomment this to view the generated code. Helpful for
debugging.
//pragma(msg, GenPow10_256Initializer);
mixin(GenPow10_256Initializer);
}
static string GenPow10_256Initializer() {
import std.range : repeat;
import std.conv : text;
string code = "pow10_256 = [\n";
foreach(i; 0..78) {
code ~= `uint256("1` ~ '0'.repeat(i).text ~ `")` ~
",\n";
}
code = code[0..$-2]; // Remove trailing comma.
code ~= "\n];";
return code;
}
```
As I said in my previous comments, this was the initial approach
for all the arrays there (I'm a very lazy person, believe me) but
the compiler complained with a nice "Out of memory" error, that's
why I ended writing the array elements by hand.
Re: Fixed size array initialization
On Sat, 10 Feb 2018 10:55:30 +, rumbu wrote:
> I know that according to language spec
> (https://dlang.org/spec/arrays.html#static-init-static) you can skip
> declaring all your elements in a fixed size array.
>
> I'm just recovering from a bug which took me one day to discover because
> of this.
>
> I have a large static initialized array, let's say int[155], and I
> forgot to declare the last element:
>
> int[155] myarray = [
>a,
>b,
>c,
>...
>//forgot to declare the 155th element
> ];
>
> I took for granted that the compiler will warn me about the fact that my
> number of elements doesn't match the array declaration but I was wrong.
>
> Does it worth to fill an enhancement on this, or this is intended
> behavior?
If you separate initialization to a static this, you'll get a compile
error:
```
immutable uint256[78] pow10_256;
static this() {
// Error: mismatched array lengths, 78 and 2
pow10_256 = [
uint256(1UL),
uint256(10UL)
];
}
```
Or if you know that no element should be the object's init value, you
could do a static foreach to validate that at compile-time.
You could also generate the elements at compile-time (this could use some
improvement, and should be generalized so a single function can generate
fillers for your other arrays as well):
```
immutable uint256[78] pow10_256;
static this() {
// Uncomment this to view the generated code. Helpful for debugging.
//pragma(msg, GenPow10_256Initializer);
mixin(GenPow10_256Initializer);
}
static string GenPow10_256Initializer() {
import std.range : repeat;
import std.conv : text;
string code = "pow10_256 = [\n";
foreach(i; 0..78) {
code ~= `uint256("1` ~ '0'.repeat(i).text ~ `")` ~ ",\n";
}
code = code[0..$-2]; // Remove trailing comma.
code ~= "\n];";
return code;
}
```
Re: Fixed size array initialization
On Sunday, 11 February 2018 at 01:26:59 UTC, psychoticRabbit
wrote:
On Sunday, 11 February 2018 at 01:13:00 UTC, psychoticRabbit
wrote:
Well, in C.. I can do:
int arr[2] = { [0]=10, [1]=20 };
I cannot work out how to do that in D yet (anyone know??)
Oh. just worked it out after reading this thread ;-)
int[2] arr = [ 0:10, 1:20 ];
This is indeed the most simple and elegant solution. Thanks.
Re: Fixed size array initialization
On Sunday, 11 February 2018 at 01:13:00 UTC, psychoticRabbit
wrote:
Well, in C.. I can do:
int arr[2] = { [0]=10, [1]=20 };
I cannot work out how to do that in D yet (anyone know??)
Oh. just worked it out after reading this thread ;-)
int[2] arr = [ 0:10, 1:20 ];
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 10:55:30 UTC, rumbu wrote:
I have a large static initialized array, let's say int[155],
and I forgot to declare the last element:
int[155] myarray = [
a,
b,
c,
...
//forgot to declare the 155th element
];
Well, in C.. I can do:
int arr[2] = { [0]=10, [1]=20 };
I cannot work out how to do that in D yet (anyone know??)
In the meantime, I'd suggest doing it this way, as you're more
likely to see that whether you forgot an element:
int[2] arr;
{
arr[0] = 10;
arr[1] = 20;
}
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 15:54:03 UTC, rumbu wrote: On Saturday, 10 February 2018 at 14:55:49 UTC, b2.temp wrote: On Saturday, 10 February 2018 at 14:35:52 UTC, rumbu wrote: In this case, it there any way to be sure that I declared all the elements I intended? Obviously, without counting them by hand. At the level of the library use a template. Sorry, but I don't get it. Can you elaborate, please? https://github.com/dlang/phobos/pull/4936
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 14:55:49 UTC, b2.temp wrote: On Saturday, 10 February 2018 at 14:35:52 UTC, rumbu wrote: In this case, it there any way to be sure that I declared all the elements I intended? Obviously, without counting them by hand. At the level of the library use a template. Sorry, but I don't get it. Can you elaborate, please? This is the array in question: https://github.com/rumbu13/decimal/blob/master/src/decimal/integrals.d#L2072 First time, I tried to use mixins to generate the array, in order to avoid writing the same thing again and again. The mixin solution was nice until the compiler served me a nice Out of Memory error, that's why I finally used a hand-written array. At the level of the compiler: no. Not only not all elements are required but they also don't need to be declared in order (static array initialization, like in the example beyond). It would be possible to put a compiler warning but warnings are not in the D philosophy (one consequence is that many people, like me use -de all the time, making a possible warning not compatible with the legit uses of the "partial array initialization"). By the way i said i did change the compiler. Actually i even captured the session to promote my IDE: http://sendvid.com/c00x7nps.
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 14:35:52 UTC, rumbu wrote: On Saturday, 10 February 2018 at 12:28:16 UTC, b2.temp wrote: On Saturday, 10 February 2018 at 10:55:30 UTC, rumbu wrote: I know that according to language spec (https://dlang.org/spec/arrays.html#static-init-static) you can skip declaring all your elements in a fixed size array. I'm just recovering from a bug which took me one day to discover because of this. I have a large static initialized array, let's say int[155], and I forgot to declare the last element: int[155] myarray = [ a, b, c, ... //forgot to declare the 155th element ]; I took for granted that the compiler will warn me about the fact that my number of elements doesn't match the array declaration but I was wrong. Does it worth to fill an enhancement on this, or this is intended behavior? I used to agree (https://issues.dlang.org/show_bug.cgi?id=17341) and even patched the compiler to emit a deprecation in this case. Then i discovered that druntime for example relies on this. The classic use case is to init a LUT where only a few elements need a non-default value, for example: ``` bool[char.max] lut = [10:true, 13:true, 9: true]; assert(!lut[46]); assert(lut[9]); ``` which can be useful. In this case, it there any way to be sure that I declared all the elements I intended? Obviously, without counting them by hand. At the level of the library use a template. At the level of the compiler: no. Not only not all elements are required but they also don't need to be declared in order (static array initialization, like in the example beyond). It would be possible to put a compiler warning but warnings are not in the D philosophy (one consequence is that many people, like me use -de all the time, making a possible warning not compatible with the legit uses of the "partial array initialization"). By the way i said i did change the compiler. Actually i even captured the session to promote my IDE: http://sendvid.com/c00x7nps.
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 12:28:16 UTC, b2.temp wrote: On Saturday, 10 February 2018 at 10:55:30 UTC, rumbu wrote: I know that according to language spec (https://dlang.org/spec/arrays.html#static-init-static) you can skip declaring all your elements in a fixed size array. I'm just recovering from a bug which took me one day to discover because of this. I have a large static initialized array, let's say int[155], and I forgot to declare the last element: int[155] myarray = [ a, b, c, ... //forgot to declare the 155th element ]; I took for granted that the compiler will warn me about the fact that my number of elements doesn't match the array declaration but I was wrong. Does it worth to fill an enhancement on this, or this is intended behavior? I used to agree (https://issues.dlang.org/show_bug.cgi?id=17341) and even patched the compiler to emit a deprecation in this case. Then i discovered that druntime for example relies on this. The classic use case is to init a LUT where only a few elements need a non-default value, for example: ``` bool[char.max] lut = [10:true, 13:true, 9: true]; assert(!lut[46]); assert(lut[9]); ``` which can be useful. In this case, it there any way to be sure that I declared all the elements I intended? Obviously, without counting them by hand.
Re: Fixed size array initialization
https://issues.dlang.org/show_bug.cgi?id=481#c40
Re: Fixed size array initialization
On Saturday, 10 February 2018 at 10:55:30 UTC, rumbu wrote: I know that according to language spec (https://dlang.org/spec/arrays.html#static-init-static) you can skip declaring all your elements in a fixed size array. I'm just recovering from a bug which took me one day to discover because of this. I have a large static initialized array, let's say int[155], and I forgot to declare the last element: int[155] myarray = [ a, b, c, ... //forgot to declare the 155th element ]; I took for granted that the compiler will warn me about the fact that my number of elements doesn't match the array declaration but I was wrong. Does it worth to fill an enhancement on this, or this is intended behavior? I used to agree (https://issues.dlang.org/show_bug.cgi?id=17341) and even patched the compiler to emit a deprecation in this case. Then i discovered that druntime for example relies on this. The classic use case is to init a LUT where only a few elements need a non-default value, for example: ``` bool[char.max] lut = [10:true, 13:true, 9: true]; assert(!lut[46]); assert(lut[9]); ``` which can be useful.
Fixed size array initialization
I know that according to language spec (https://dlang.org/spec/arrays.html#static-init-static) you can skip declaring all your elements in a fixed size array. I'm just recovering from a bug which took me one day to discover because of this. I have a large static initialized array, let's say int[155], and I forgot to declare the last element: int[155] myarray = [ a, b, c, ... //forgot to declare the 155th element ]; I took for granted that the compiler will warn me about the fact that my number of elements doesn't match the array declaration but I was wrong. Does it worth to fill an enhancement on this, or this is intended behavior?
