On-the-Fly Collections/Dictionaries (params IEnumerable v2)

[TonyValenti]

Here's what I would like to be able to do:

1. I propose that syntax like {1,2,3,4,5} be shorthand for "Create a new Collection of the given type.

2. The "given type" of the collection should be as follows:
   2.a. var x = {1,2,3,4,5}; //array of Best common type. In this case, int[]
   2.b. double[] x = {1,2,3,4,} //array of double. Target Typing
   2.c.

public void Foo<T>(
  [DefaultImplementation(typeof(List<T>))] IEnumerable<T> Values1
)
...
Foo( {1,2,3,4}); //List<T>.  The type comes from the attribute

With syntax like this, I it removes the need for any work to be done on improving "params" because it is so easy to just type the curly braces and list all the values out that way. It also basically makes it possible to do 'Params Anywhere' because you can do:

Foo( {1,2,3,4,5}, {"John", "Mary"}, { });

[quinmars]

That syntax is in conflict with the existing initalizer syntax:

var e = new Employee
{
    Name = "Doe, John",
    NickNames = { "Johnny", "Jojo" }
};

[TonyValenti]

@quinmars -
It isn't in conflict, it is purposefully the same. If we can easily initialize a collection in an initializer, why not anywhere else?

[333fred]

@TonyValenti the initializer syntax does not create a new collection, it initializes an existing one, and that example will almost certainly null ref if NickNames is null. It would be very confusing if in one area {1, 2} initialized an existing instance, and everywhere else it created a new instance.

[MillKaDe]

If you add new [] before the opening curly brace, it already works:

Try at SharpLab

using System;
using System.Collections.Generic;
using System.Linq;
public class C {
  public static void Main() {
    Enumerate (new int[] {1, 2, 3});
    Enumerate (new [] {4, 5, 6});
    Enumerate (new string[] {"a", "b", "c"});
    Enumerate (new [] {"d", "e", "f"});
    Enumerate2 (new [] {4, 5, 6}, new [] {"d", "e", "f"});
  }
  public static void Enumerate<T> (IEnumerable<T> seq) {
    foreach (var t in seq)
      Console.WriteLine ($"{t.GetType ()}: {t}");
  }
  public static void Enumerate2<T1,T2> (IEnumerable<T1> seq1, IEnumerable<T2> seq2) {
    foreach (var t in seq1.Zip (seq2))
      Console.WriteLine ($"{t.GetType ()}: {t}");
  }
}

output:

System.Int32: 1
System.Int32: 2
System.Int32: 3
System.Int32: 4
System.Int32: 5
System.Int32: 6
System.String: a
System.String: b
System.String: c
System.String: d
System.String: e
System.String: f
System.ValueTuple`2[System.Int32,System.String]: (4, d)
System.ValueTuple`2[System.Int32,System.String]: (5, e)
System.ValueTuple`2[System.Int32,System.String]: (6, f)

[huoyaoyuan]

This should be covered by target-typed new(#100).
Given current syntax:

Foo(new List<int>{ 1, 2, 3, 4, 5 });

It's seamless to use this:

Foo(new { 1, 2, 3, 4, 5});

A new keyword will clarify for whether a new instance is created.