Любая достаточно сложная программа на Си или Фортране содержит заново написанную, неспецифицированную, глючную и медленную
реализацию половины языка Common Lisp.

N>let put o = o#put o
N>

Error: This expression has type < put : unit >
       but an expression was expected of type < put : 'a -> 'b; .. > as 'a
       Types for method put are incompatible

method put x = printf "O2\n"

W>в 4й шарп всадили динамическую типизацию (dynamic)/ Видать, без нее — никак

In most cases, it functions like it has type object. At compile time, an element that is typed as dynamic is assumed to support any operation. Therefore, you do not have to be concerned about whether the object gets its value from a COM API, from a dynamic language such as IronPython, from the HTML Document Object Model (DOM), from reflection, or from somewhere else in the program. However, if the code is not valid, errors are caught at run time.

DoSomething(list)
{
  return list.Select(x => x.Foo + x.Bar); 
}

Я пока не видел явной пользы от динамика, перевешивающей все прелести статической типизации. Явное исключение — всякие DOM для документов с заранее неизвестной схемой.

H>Казалось бы...

val x : { def foo[T](y : T) : String; val y : Integer }
val y : { def foo[T <: C](y : T) : Any; }

y = x
y.foo(new C)

interface IConverter<T>
{
    T Convert(T x);
}

class IntConverter : IConverter<int>
{
    public int Convert(int x)
    {
        return x * 2;
    }
}

class StringConverter : IConverter<string>
{
    public string Convert(string x)
    {
        return x.ToUpper();
    }
}

static void Foo<T>(IConverter<T> conv, T x)
{
    T y = conv.Convert(x); // здесь может быть вызван и IntConverter.Convert(int), и StringConverter.Convert(string)
}

open Printf

let o1 = object 
  method put = printf "O1\n"
  end
  
  
let o2 = object 
  method put = printf "O2\n"
  end


let put o = o#put


let _  = put o1
let _  = put o2

let put o = o#put o