Collection Expressions: Implicity type ins't supported.

[nathan130200]

I don't understand the purpose of the collections expression, if even when the type is implicitly defined it still causes a compilation error CS9176.

See an example below, an array of only Encoding objects, this is very clear, I can't just use var encodings and declare them. It is unnecessary to have to write Encoding[] encodings = [...] when the variable is already clear what it is. If it is not then interpret it as object[] instead of causing a compilation error.

using System;
using System.Text;

// It's obvious, it's an array of `System.Text.Encoding` so the compiler can't understand that?
var encodings = [ 
    Encoding.ASCII,
    Encoding.UTF8,
    Encoding.Latin1,
    Encoding.BigEndianUnicode,
    Encoding.Unicode
];

foreach(var enc in encodings){
    Console.WriteLine("Name={0}; Web Name={1}", enc.BodyName, enc.WebName);
}

Instead:

// This makes the code look ugly, you need to declare the 
// type explicitly when the type is already obvious.
Encoding[] encodings = [ 
    Encoding.ASCII,
    Encoding.UTF8,
    Encoding.Latin1,
    Encoding.BigEndianUnicode,
    Encoding.Unicode
];

In case of mixed types defined, interpret as object array:

// Mixed content, will be treated as `Object[]`
var context = [
  "my string",
  1234,
  false
];

[HaloFour]

Natural typing for collection expressions is something that is planned for C# 13/14. The issue isn't determining the element type, it was settling on the best option for the collection type itself depending on the situation.

See: #7913

[jnm2]

Not coming in 13 for sure.

[CyrusNajmabadi]

See an example below, an array of only Encoding objects, this is very clear

It's definitely not clear to me :-)

Should it be an array, a span, a list, or something else entirely?

// Mixed content, will be treated as `Object[]`
var context = [ "my string", 1234, false ];

And what about:

 var context = [ "x": "my string", "y": 1234, "z": false ];

?

[nathan130200]

It's one of the proposed syntax for dictionary expression. Whether it should produce dictionary or collection of kvp is unclear.

This will be a terrible syntax for dictionaries. Instead should use {"key": "value"} rather than ["key":"value"]

And apply same concept. Declaring entries with mixed Value types Dictionary<string, object> considering that the Key is string (or if key is mixed too Dictionary<object, object>)

[colejohnson66]

"key":"value" prevents other dictionary types that aren't string-keyed. C# is not JSON.

[DavidArno]

@colejohnson66, I think you may have misunderstood the syntax. This would also be possible (and would still fit Cyrus's question of what type should the compiler use to resolve it:

var context = [ Color.Red: "my string", Color.Green: 1234, Color.Blue: false ];

[KennethHoff]

Given ad hoc unions, Dictionary<Color, (string or int or bool)> seems like a good starting place.

ReadOnlySpan<KeyValuePair<Color, (string or int or bool)>> is also a good candidate.

[DavidArno]

@KennethHoff, my comment about it depending on what comes next in the code applies here:

var context = [ Color.Red: "my string", Color.Green: 1234, Color.Blue: false ];
context.Add(Color.Yellow, 1.01); // I'd be very unhappy if this didn't compile due to the compiler assuming (string or int or bool)

[KennethHoff]

using System;
using System.Text;

// It's obvious, it's an array of `System.Text.Encoding` so the compiler can't understand that?
var encodings = [ 
    Encoding.ASCII,
    Encoding.UTF8,
    Encoding.Latin1,
    Encoding.BigEndianUnicode,
    Encoding.Unicode
];

foreach(var enc in encodings){
    Console.WriteLine("Name={0}; Web Name={1}", enc.BodyName, enc.WebName);
}

encodings being Encoding[] might be obvious, but it's not the best choice. It really should be ReadOnlySpan<Encoding> because it's exclusively used for enumeration. In fact it arguably shouldn't even be that, and instead it should be emitted as an unrolled loop.

[huoyaoyuan]

I believe the compiler should get the leniency to unroll the loop if the collection isn't used in other ways.

[RikkiGibson]

I don't understand the purpose of the collections expression

The feature was designed with the reality of C# collections in mind, which is that there isn't one array-like collection that rules them all. There's a mix of T[], List<T>, Span<T>/ReadOnlySpan<T>, interfaces, etc. The design effort so far has gone into doing the best thing to create the specific collection type, when that type is known (including when a type inference is needed to decide the element type for the collection).