Collection Expressions: Eliminate [ ] when used with Single-item collection

[TonyValenti]

This morning I wrote this code:

        var ret = new MultiResponseJson<AlertJson>() {
            Data = [
                ..  from x in Json
                    let V = new ResponseJson<AlertJson>() {
                        Data = x
                    }
                    select V
            ],
        };

        return ret;

And I thought it would look better if I could eliminate the [ ] from collection expressions that contain a single ... item.

ie:

        var ret = new MultiResponseJson<AlertJson>() {
            Data =
                ..  from x in Json
                    let V = new ResponseJson<AlertJson>() {
                        Data = x
                    }
                    select V
        };

        return ret;

[HaloFour]

That's already a legal expression, a LINQ query that produces an IEnumerable<T>. Without the [ ] the .. operator means a range, not a spread.

A single-item collection is still a collection, to me the [ ] makes the expression much clearer. How would the compiler know or enforce that said special syntax would only apply to single-item collections anyway? What happens if the collection doesn't have exactly one item?

[jnm2]

I don't think Tony meant single-item so much as single-expression (element or spread).

[HaloFour]

I guess that would have to be a single spread given a single element expression would be a completely different type if you omitted the [ ]. Either way, I still think that the brackets are the most important aspect of the expression and make it very clear what you're trying to do. Without them it's a game of spot the dots.

[jnm2]

What is it about today's syntax that looks subjectively worse?

Not that this is "the way" or anything, but this is how I've been formatting code like that:

var ret = new MultiResponseJson<AlertJson>
{
    Data = [..
        from x in Json
        let v = new ResponseJson<AlertJson> { Data = x }
        select v],
};

Since I place { and } on their own lines, but I'm not placing [ on its own line, I'm not placing ] on its own line either.

[huoyaoyuan]

The auto conversion of singleton collection is my least favor behavior of PowerShell. Element and collection are different order of types.

[CyrusNajmabadi]

@huoyaoyuan I don't think this is autoconversion. In @TonyValenti's case he has the .. indicating he's spreading. It's just saying that [.. x] and .. x would be equivalent.

The major blocker here is that .. x is already legal syntax (And means "a range with only the end specified"). If we didn't have that meaning already, this could be more palatable.

[jnm2]

@CyrusNajmabadi I do think of it as autoconversion, actually, and my initial reaction was the same as @huoyaoyuan's. Consider how collection = singleItem is auto conversion, and the "splatting" sense of .. puts collection = .. multiple on the same footing as collection = singleItem. Where wrapping both with [...] makes the conversion from element-land to collection-land an explicit one.