a struct as an multidimensional array index

[z]

On Saturday, 11 June 2022 at 03:56:32 UTC, Chris Katko wrote:
> On Friday, 10 June 2022 at 17:26:48 UTC, Ali Çehreli wrote:
>> On 6/10/22 08:13, z wrote:
>>
>> > arrays of arrays has different order for declaration and
>> addressing,
>> > and declaring array of arrays has different order depending
>> on how you
>> > declare it and wether it's static or dynamic array, *oof*)
>> >
>> > To give you an idea of the situation :
>> > ```D
>> >      int[3][1] a;//one array of 3 int
>> >      writeln(a[0][2]);//first "column", third "row"
>> > ```
>>
>> I've written about this multiple times in the past but D's way 
>> is consistent for me. That must be because I always found C's 
>> syntax to be very illogical on this. To me, C's problem starts 
>> with putting the variable name in the middle:
>>
>>   // C code:
>>   int a[1][3]; // Why?
>>
>> So, first, D moves the variable to its consistent place: after 
>> the type:
>>
>>   int i;
>>   int[N] arr;
>>
>> Both of those are in the form of "type and then name". Good...
>>
>> And then, here is the consistency with arrays: "type and then 
>> square brackets".
>>
>>   int[] dynamicArray;
>>   int[N] staticArray;
>>
>> So, here is where you and I differ:
>>
>>   int[3][1] arr;  // Ali likes
>>   int[1][3] arr;  // z wants
>>
>> I like it because it is consistently "type and then square 
>> brackets". (It so happens that the type of each element is 
>> int[N] in this case.) If it were the other way, than array 
>> syntax would be inconsistent with itself. :) Or, we would have 
>> to accept that it is inside-out like in C.
>>
>> But of course I understand how it is seen as consistent from 
>> C's point of view. :)
>>
>> And this is consistent with static vs dynamic as well because 
>> again it's "type and then square brackets":
>>
>>   int[1][] a;  // A dynamic array of int[1]
>>   int[][3] b;  // A static array of 3 int[]s
>>
>> Ali
>
> This is an interesting discussion. I had noticed multi-dim 
> arrays seemed backwards but I assumed I was doing something 
> wrong and had other thing to worry about. I had no idea it was 
> DIFFERENT for static vs dynamic arrays? That's horrifying!
>
> Also you reminded me of a possible D bug that I ran into. I had 
> classes that had circular dependencies. One had to know about 
> the other, and vice-versa. And I had derived classes. But 
> somehow, they would explode. I would send one reference to the 
> others constructor to 'link' them together, but the reference 
> would be NULL. But if I accessed the exact same variable 
> through a global reference, it worked fine.
>
> I tried ripping the affected code into a new file but the bug 
> wasn't replicated. Even if I matched the compiler/linker 
> options. It was super frustrating.

I rechecked and it should be `X Y Z` for static array, but `Z Y 
X` for indexing/dynamic array creating with `new`
(e.g. `float[][][] arr = new 
float[][][](third_dimension,second_dimension,first_dimension;`)

The dillema is that alone, the orders are sound byproducts of the 
language rules, it's when they are put in relation to each other 
that it can become weird.

The bug could also be one of those implementation-specific bugs 
that are seemingly impossible to reproduce minimally because they 
require unknown very specific conditions to occur. Self and inter 
referencing appears unstable whenever it is not in the 
module/global scope.