Discussion: mixed initializer styles

[alrz]

Currently both of these are valid initializers:

new StreamContent() { Headers = { ContentType = ct } };
new StreamContent() { Headers = { { "X-Header", h } } };

but not when they are mixed in a single initializer

new StreamContent() { Headers = { ContentType = ct, { "X-Header", h } } };

Looks like the parser already produce a valid tree for this, but the compiler eventually rejects it.

Could we relax the rules so that this is permitted?

[YairHalberstadt]

I find this a little confusing:

using System.Collections.Generic;

public class C {
    public void M() {
        var list = new List<int>
        {
           Capacity = 100,
           1,
           2,
           3,
        };
    }
}

At first glance it looks like there's 4 items in the list, but actually theres 3.

However it could well be that if I got a little more used to this, I wouldn't find it so strange. But I think it would be nice to do some user studies on that.

[alrz]

        var list = new List<int>
        {
           Capacity = 100,
           1,
           2,
           3,
        };

That case raises an ambiguity that currently is avoided precisely because you could either have a collection initializer or an object initializer, e.g. with the name Capacity in scope, it will be assigned and the result will be added to the collection. My example is not ambiguous because we're passing more than one value.

[quinmars]

int Capacity;
var list = new List<int>
{
    Capacity = 100,
    1,
    2,
    3,
};

Does not compile today. So it would not be a breaking change.

[YairHalberstadt]

But this does:

int Capacity;
var list = new List<int>
{
    (Capacity = 100),
    1,
    2,
    3,
};

It might be a bad idea for them to have two separate meanings, but it's rare enough I don't think it matters.

[quinmars]

Those two separate meanings are already present, however, not at the same time.

int Capacity;
var l1 = new List<int>
{
    Capacity = 100     // l1.Capacity = 100;
};
        
var l2 = new List<int>
{
    (Capacity = 100)   // l2.Add(100);
};

[mattwar]

This way its not ambiguous though.

var list = new List<int>(new [] { 1, 2, 3 }) { Capacity = 100 };

Maybe we should work on turning it into this:

var list = new List<int>({ 1, 2, 3 }) { Capacity = 100 };

Target-typed collection initializer anyone?

[vladd]

@mattwar What should be the type of { 1, 2, 3 }? Is it a kind of array literal (as in int[] a = { 1, 2, 3 }), or it's contextually typed like lambda expressions?

[mattwar]

It was supposed to be an array initializer for a target-typed array/collection. It was for the argument to List(IEnumerable).

[vladd]

@mattwar So a kind of array literal, right? Or you meant it to be interpreted differently in other contexts, e. g. List<int> l = { 1, 2, 3 }; (so target-typed subclass of IEnumerable<T> defaulting to array)?

[mattwar]

For this case

List<int> x = { 1, 2, 3 };

would be interpreted as

List<int> x  = new List<int> { 1, 2, 3 };

But for cases where the target type is not a constructable class, but is assignable from array, like IEnumerable, IReadOnlyList, etc.

IEnumerable<int> x = new int[] { 1, 2, 3 };

[vladd]

@mattwar Thank you for the explanation! Nice idea, is there an github issue to track its progress anywhere?

BTW I'd expect IEnumerable<int> x = { 1, 2, 3 }; to produce actually an instance of some immutable collection rather then an array.

[mattwar]

@vladd not yet.

[alrz]

For this case

List<int> x = { 1, 2, 3 };

would be interpreted as

List<int> x  = new List<int> { 1, 2, 3 };

Using target-typed new, you can write

List<int> x  = new() { 1, 2, 3 };

If you don't mind new(), I think it covers the case where a target-typed initializer could be used.

Edit: Actually new() helps with some nasty syntax ambiguities if we want to keep {} on the literal. I think [] would be more appropriate, however with new() {} in place I'm not sure if that would worth it.