Proposal for fixed declaration array syntax, with array index order closer to C

[joshring]

Proposal for fixed declaration array syntax, with array index order closer to C

    // C3 current syntax
    int[4][2] arr = {
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
    };

    // C syntax
    int arr[2][4] = {
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
    };

    // Proposal - matches Row major memory layout and C syntax
    int[2,4] arr = {
        { 1, 2, 3, 4 },
        { 5, 6, 7, 8 },
    };

    // All access with the same syntax
    int eight = arr[1][3]; // 8

Why:

• Closer to C for index order
• Symmetry between access index order and declaration index order
• Declarations are rarer than access, so fewer code changes than if we adjusted the access syntax

[lerno]

As declaration syntax these are the downsides:

1. If int[4][2] is thought of as [x-size][y-size], then the declaration order is as expected.
2. It is a special syntax only applicable to non-jagged multi dimensional arrays.
3. It doesn't actually enable any new features.
4. It makes the language larger

[lerno]

If one wants to enforce the x, y, z ordering, then arr[x, y, z] could be introduced, where this is accessed as arr[z][y][x]

[lerno]

I have been reluctant to hog the int[a, b, c] and arr[x, y, z] syntax in case I'd ever support matrix types.

[joshring]

If you also wanted to support matrices it would be a lot harder to implement presumably due to the ambiguous syntax?

[lerno]

It's more that you want syntax to have a single meaning.

[joshring]

Maybe we need to pencil in a syntax for future matrices inspired by how vectors are defined?

int[<4,2>] matrix;    // possibly like this?
int[4,2] fixed_array;

This appears to be consistent with how vectors are related to 1D arrays?
It seems to also be consistent with C where index order and also unique so is unambiguous with the multidimensional fixed array syntax proposal.

[joshring]

Other possible candidates for fixed array syntax:

int([4,2]) fixed_array;

int[|4,2|] fixed_array;

[chqrlie]

Hello! Just discovered C3 and puzzled by some of the design choices.

Why not use the same order as C ?

• it is consistent with the mantra: Being close to C for C programmers is a major priority for the language.
• makes the declaration syntax consistent with the usage syntax
• should not be such a big deal to parse.

I understand it is quite late to change this, but such departures from C are a major headache for adoption.

[lerno]

The order of declaration in C is based on the spiral rule. Recall how int[10] x is declared int x[10] due to this.

If we want to avoid placing the array declaration on the left (which is problematic outside of simple declarations) then problems appear.

In C3, the order is right to left, peeling layers, so that a int[10]*[20] type means an array of 20 int[10]* which in turn is a pointer of int[10]` and so on.

Similarly, you make a generic list of an array of ints you would write List(<int[20]>) and an array of that list would be List(<int[20]>)[10]

This would then be indexed like a[1][2][3]

Where a[1] returns the List, a[1][2] returns the int[20] and so on.

Now let's think of this in C terms and pretend it's a multidimensional int array: int a[10][][20]

But if we try to make it a type in front:
int[10][][20] a then things get weird:

How would you represent the generic in a normal way?

Something like List(<int[20]>[10] a; presumably and we "lost" the "C" order anyway.

The spiral rule is complicated and in general not considered a good design. It's also complicated to parse and fits poorly with other features with types.

But the compromise: to retain spiral rule array ordering, leads to weird things when working with generic types and overloading.