using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var y = new List<int> {1, 2, 3};
        var z = y.ConvertAll(ConvertToString);
    }

    static string ConvertToString<T>(T x)
    {
        return x.ToString();
    }

    static string ConvertToString(Guid x)
    {
        return x.ToString("N");
    }
}

• We then examine each bound for Xi in turn: For each exact bound U of Xi all types Uj which are not identical to U are removed from the candidate set. For each lower bound U of Xi all types Uj to which there is not an implicit conversion from U are removed from the candidate set. For each upper bound U of Xi all types Uj from which there is not an implicit conversion to U are removed from the candidate set.

var dict = new Dictionary<,> {
    { 1, "abc" },
    { 2, "def" }
};

П>>

П>>var dict = new Dictionary<,> {
П>>    { 1, "abc" },
П>>    { 2, "def" }
П>>};
П>>

Другое дело в том, насколько это будет непонятно

let foo =
    let d = new Dictionary<_,_>()
    d.Add(1, "abc")
    d.Add(2, "def")
    d

П>let foo =
П>    let d = new Dictionary<_,_>()
П>    d.Add(1, "abc")
П>    d.Add(2, "def")
П>    d
П>

П>Мне всё же кажется, что это неспроста

using System.Collections.Generic;
using System.Console;

module Program
{
  Main() : void
  {
    def d = Dictionary();

    d.Add(1, "abc");
    d.Add(2, "def");

    foreach (x in d)
      WriteLine($"$(x.Key)=$(x.Value)");
  }
}

class Foo
{
  public this(a : int) { }
}

class Foo[T]
{
  public this(a : T) { }
}

module Program
{
  Main() : void
  {
    def x = Foo(5);
  }
}

    def x = Foo(5) : Foo[int];

П>class Foo
П>{
П>  public this(a : int) { }
П>}

П>class Foo[T]
П>{
П>  public this(a : T) { }
П>}

П>module Program
П>{
П>  Main() : void
П>  {
П>    def x = Foo(5);
П>  }
П>}
П>

def x = Foo.[int](5);

def x = Foo.[_](5);