A small oddity when it comes to array initialization

[iam3yal]

In the following cases the compiler complains that it can't resolve the type based on the current information and I'm wondering what's the reason for it? it seems a bit odd that the shorthand works but the more explicit syntax doesn't.

Case 1:

byte[] table = new [] { };

Case 2:

byte[] table = new [] { 48 };

However, it works when we use the array initializer syntax:

byte[] table = { };

Anyway, just thought to point it out.

[mattwar]

The older array initializer has always been target typed. You can only use it in a variable initializer, and it uses the type of the variable. (note that you cannot use the array initializer syntax with var). The other two initializers are not target typed. They are inferring the array type from the elements specified. The first example has no elements. The second example has a single value which must be understood as int, and is then incompatible with byte[].

[iam3yal]

@mattwar Thanks for the explanation, just an opinion though, it was nicer if I didn't have to ask and it's just worked but then I guess no language is perfect. :)

[jnm2]

Never thought I'd say it but perfection is subjective. :-)

[mattwar]

We seemed to be adding a lot of target typed features into the language now, so maybe there is hope.

[iam3yal]

@jnm2 I guess so but what I really meant is I wish the transition between one syntax to another for the "same" thing was smoother or better so I thought to bring this up 😉

@mattwar Thanks! 😄

[dsaf]

How about this:

var table = byte[]; //Array.Empty<byte>();
byte[] table = []; //Array.Empty<byte>();

[Pzixel]

@dsaf C# is not JS 😄
I don't think we need a special syntax for empty arrays because they are pretty rare. Unlike JS, we cannot push in empty array so JS pattern like

var arr = [];
for(...)
   arr.push(something)

is not applicable here.

[dsaf]

@Pzixel
This sort of syntax is called a "literal". For example "" is a literal for string.Empty.
Empty collections are pretty frequent and I choose to use arrays behind of IReadOnlyCollection<> for simplicity.
For example Roslyn uses Array.Empty more than 100 times: https://github.com/dotnet/roslyn/search?utf8=%E2%9C%93&q=%22array.empty%22&type=
E.g. Swift and F# have very short syntax for different collection literals, Kotlin considers it as well. I think Rust might have something too. I recon we will see this syntax by C#10.1 😉.

[Pzixel]

@dsaf so what? it's 145 from 5051938sloc = 1 occurence per 35k lines of code. There are 202 Task.FromResult, so we more likely want to add syntax for Task.FromResult than for empty arrays. It's easy to add this syntax, but I don't see how we would benefit from it. It's just extra-rare, as you showed us.

[iam3yal]

@dsaf Might be more useful to create an issue about it than a comment though, I mean, if you really want it. :)

[gulshan]

Literals for Dictionaries( and Lists and their types) is being discussed in #414