syntax change for fixed arrays needs to be implemented

[JalonSolov]

Fixed arrays can currently be declared either by [<size>]<type>{} for an empty array, or [<type cast>(value), value2, value3, ...]!.

However, a discussion was started by Alex in November 2024, here: https://discord.com/channels/592103645835821068/700746775962714232/1306274293054832800

The final decision was that fixed arrays should be changed to the following syntax
[<size>]<type>[<values>], or [..]<type>[<values>] where the literal .. for the size means the compiler should count the number of values between the second [ and ] pair.

Also, the [<size>] part can be specified multiple times for multi-dimensional arrays.

Examples:

arr1 := [4]f32[1 2 3 4]

arr2 := [4][4]f32[
 [1 2 3 4]
 [5 5 4 2]
 [0 1 3 0]
 [0 1 4 1]
]

// etc., etc.  The same arrays could also be entered as
arr3 := [..]f32[1 2 3 4]

arr4 := [..][..]f32[
 [1 2 3 4]
 [5 5 4 2]
 [0 1 3 0]
 [0 1 4 1]
]

// using literal numbers for sizes makes it explicit without anyone having to count
// the number of values again.

// using `..` for sizes means you can freely add/remove values, and the compiler
// will handle the changes by counting the number of values at compile time.

Note

You can use the 👍 reaction to increase the issue's priority for developers.

Please note that only the 👍 reaction to the issue itself counts as a vote.
Other reactions and those to comments will not be taken into account.

[huly-for-github]

Connected to Huly®: V_0.6-24258

[jorgeluismireles]

Last year I got confused with the ! syntax for both Results and fixed arrays: #22849 . Will v fmt help with the transition?

[JalonSolov]

It should. It is supposed to help resolve syntax changes.

[Larsimusrex]

I find it weird to have two ways of specifying the type. Wouldn't it be better if it's also done with a type cast

[0, 1, 2, 3] // dynamic, assume int
[..][0, 1, 2, 3] // fixed, assume int

[u8(0), 1, 2, 3] // dynamic, use u8
[..][u8(0), 1, 2, 3] // fixed, use u8

[JalonSolov]

The older syntax would be deprecated, not allowed along with the new one.

It would also be better to always give the type, instead of assuming int as the type.

The people requesting this change do NOT like the cast on the first element, as it messes up the formatting of the rest (which is why the change to [4]u8[0 1 2 3] from [u8(0), 1, 2, 3]!).

It also gets rid of the trailing ! meaning fixed array (which nobody has really liked).

[Larsimusrex]

So, dynamic arrays would be declared int[0 1 2 3] instead of [0 1 2 3]?

Could the constant array declaration also use the new fixed syntax, e.g. const lookup = [4]int[1 2 4 9]. I always found it confusing why that would use the dynamic syntax when it results in a fixed array.

[JalonSolov]

Dynamic arrays would just be [] in front, with no size given, so []int[0 1 2 3]

Yes, the same syntax should apply everywhere.

[kbkpbot]

How about an empty array?
[]int[] or []int or []int{} ?

a fixed array with all default values?
[4]int[] or [4]int[0 0 0 0] or [4]int{} or just [4]int?

And what is the meaning of [..]int[] or [..]int?

[JalonSolov]

Empty dynamic array is []int{}, same as now.

Uninitialized (all 0's) fixed array would be [4]int{}.

Fixed array with default non-zero values would be [4]int[1 2 3 4]

[..] means "V should count the number of values, and set the size accordingly". So [..]int[1 2 3 4 5] would mean the same as [5]int[1 2 3 4 5], except V would count the values and set the 5 itself at compile time.

Why have a separate way to set the size? So you don't have 2 things to edit if you change the number of values - the values themselves and the size.