...params parameter-passing without any heap allocation.

void Foo(params Span<int> values);

public class Greeter(name: string)

var x = ["foo":4, "bar": 5];

System.UTF8String myUTF8string ="Test String";

public shape SGroup<T>      
{      
    static T Combine(T t1, T t2);      
    static T Identity { get; }
}

var x = new Dictionary<string, int> { { "foo", 4 } };
x = new Dictionary<string, int> { ["foo"] = 4 };
x = ["foo": 4];

BE>System.UTF8String myUTF8string ="Test String";  
BE>

var dict = new Dictionary<_, _> { { "key1", 0}, { "key2", 1} };

var r = default(Rational);

J>var dict = new Dictionary<_, _> { { "key1", 0}, { "key2", 1} };
J>

class Holder
{
  public static Holder<T> Create<T>(T value) => new Holder<T>(value); // костыль для type inference
}
сlass Holder<T>
{
  private T _value;
  public Holder(T value) => _value = value;
}

...
var h1 = Holder.Create(42); // ok
var h2 = new Holder<>(42); // низзя, а можно было бы.

var dict = new XYZWUI { { "key1", 0}, { "key2", 1} };

var dict = new XYZWUI();
dict.Add("key1", 0); // <- вот здесь у нас появилась информация о типах аргументов.
dict.Add("key2", 1);

var d1 = new Dictionary<string, int> {{"key"}:1}
var d2 = new Dictionary<string, float> {{"key"}:1}

var d1 = new Dictionary<,> {{"key"}:1}

    var d2 = new MyClass() { {"A", 2, 3}, { 4, 5, 6 } }; // Ok
...
    public class MyClass: IEnumerable
    {
        public MyClass() {}
        public void Add(string a, int b, double c) => Console.WriteLine($"initializing {a}={b}[{c}]");
        public void Add(int a, int b, double c) => Console.WriteLine($"initializing {a}={b}[{c}]");

        public IEnumerator GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }

    var d3 = new CrazyDict<,> { {"A", 2 } }; // ??
...
    public class CrazyDict<K, T>: IEnumerable
    {
        public CrazyDict() {}
        public void Add(K key, T value) => Add((object) key, value);
        public void Add(object key, object value) => Console.WriteLine($"initializing {key}={value}");

        public IEnumerator GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }

J>>var dict = new Dictionary<_, _> { { "key1", 0}, { "key2", 1} };
J>>

var dict = new Dictionary { { "key1", 0}, { "key2", 1} };

var dict = { { "key1", 0}, { "key2", 1} };

S>var d1 = new Dictionary<string, int> {{"key"}:1}
S>var d2 = new Dictionary<string, float> {{"key"}:1}
S>

S>var d1 = new Dictionary<,> {{"key"}:1}
S>

J>>var dict = new Dictionary<_, _> { { "key1", 0}, { "key2", 1} };
J>>

S>var dict = new XYZWUI { { "key1", 0}, { "key2", 1} };
S>

S>var dict = new XYZWUI();
S>dict.Add("key1", 0); // <- вот здесь у нас появилась информация о типах аргументов.
S>dict.Add("key2", 1);
S>

var i = new[] {GetString(),GetString(),GetString()};

S>    var d3 = new CrazyDict<,> { {"A", 2 } }; // ??
S>...
S>    public class CrazyDict<K, T>: IEnumerable
S>    {
S>        public CrazyDict() {}
S>        public void Add(K key, T value) => Add((object) key, value);
S>        public void Add(object key, object value) => Console.WriteLine($"initializing {key}={value}");

S>        public IEnumerator GetEnumerator()
S>        {
S>            throw new NotImplementedException();
S>        }
S>    }
S>

    public class CrazyDict2: IEnumerable
    {
        public CrazyDict() {}
        public void Add<K, T>(K key, T value) => Add((object) key, value);
        public void Add(object key, object value) => Console.WriteLine($"initializing {key}={value}");

        public IEnumerator GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }

    var d3 = new CrazyDict2() { {"A", 2 } };

var dict = Dictionary(("val1", 1), ("val2", 2));

public shape SGroup<T>      
{      
 static T operator +(T t1, T t2);      
 static T Zero {get;}       
}

This declaration says that a type can be an SGroup<T> if it implements a+ operator over T, and a Zero static property.

public extension IntGroup of int: SGroup<int>    
{    
 public static int Zero => 0;    
}

And the extension.

public static AddAll<T>(T[] ts) where T: SGroup<T> // shape used as constraint    
{    
 var result = T.Zero; // Making use of the shape's Zero property    
 foreach (var t in ts) { result += t; } // Making use of the shape's + operator    
 return result;    
}

Let us call the AddAll method with some ints,

int[] numbers = { 5, 1, 9, 2, 3, 10, 8, 4, 7, 6 };        
WriteLine(AddAll(numbers)); // infers T = int