public class TemplateT<A> where A has { A Operation(); }
        {
            A DoubleOperation(A arg)
            {
                return arg.Operation().Operation();
            }
        }

let inline doubleOperation arg = 
    let oper a = (^a : (member Operation : unit -> ^a) a)
    oper (oper arg)

type Foo(x:int) =
     member self.Value = x
     member self.Operation() = Foo(x + 1)

doubleOperation(Foo(3)).Value
(* val it : int = 5 *)

The member-sig may not be generic, i.e. may not include explicit type parameter definitions.

public T Square(T value) where T : IArithmetical
{
  return value * value;
}

public interface IExecutable
{
   void Execute();
}
public T Code<T>(T arg) where T simular IExecutable
{
    atg.Execute();
}

public T Code<T>(T arg) where T simular <IntefaceType>

public abstract FilterBase<T, ValueT> where T has { ValueT R { get; set; } ValueT G { get; set; } ValueT B { get; set; } ValueT A { get; set; }  
//simular IPixelData<ValueT>
{
public Bitmap<T> Context { get; private set; }
public abstract double ApplianceStrength(T pixel, int x, int y);
public abstract T Apply(T pixrl, int X, int Y); 
public virtual void Apply()
{
   foreach(PixelCoordInfo<T> p in Context.EnumerateAllPixels())
   {
        Context[p.x, p.y] = Aply(p.Pixel, p.X, p.Y); 
   }
}
}

K>        public class TemplateT<A> where A has { A Operation(); }
K>        {
K>            A DoubleOperation(A arg)
K>            {
K>                return arg.Operation().Operation();
K>            }
K>        }
K>

public interface COperationable<A> { A Operation(A arg); }

//Foo - класс или структура, которую мы не можем изменить.
public type Foo implements COperationable
{
    A Operation(A arg)
    {
     //реализация
    }
}

public class TemplateT<A> where A : class COperationable
{
  A DoubleOperation(A arg)
  {
    return arg.Operation().Operation();
  }
}

...

var tt = new TemplateT<Foo>();

public interface COperationable<A> { A Operation(A arg); }

[Implementation("Foo", "COperationable")]
public struct Foo_COperationable : COperation<Foo>
{
    A Operation(A arg)
    {
     //реализация
    }
}

[Implicit("CT")]
[ClassType("A", "COperationable")]
public class TemplateT<A, CT> where CT : COperationable<A>, new()
{
    static CT ct = new CT();
  A DoubleOperation(A arg)
  {
    return ct.Operation(ct.Operation(ct));
  }
}

...
//компилятор подставляет второй неявный параметр,
//подбирая соответствующую реализацию для типа Foo из области видимости.
var tt = new TemplateT<Foo, Foo_COperationable>();

static void Main()
{
    Console.WriteLine(Calc(5, 2, 3.0));
}

public static T2 Calc<T1,T2>(T1 x, T1 y, T2 z)
{
    return Operator.Division(
        ConvertTo<T2>.From(Operator.Addition(x, y)),
        z);
}

K>>public T Code<T>(T arg) where T simular <IntefaceType>
K>>

public object this[object key] { get; set; }

K>>        public class TemplateT<A> where A has { A Operation(); }
K>>        {
K>>            A DoubleOperation(A arg)
K>>            {
K>>                return arg.Operation().Operation();
K>>            }
K>>        }
K>>

K>public interface COperationable<A> { A Operation(A arg); }

K>//Foo - класс или структура, которую мы не можем изменить.
K>public type Foo implements COperationable
K>{
K>    A Operation(A arg)
K>    {
K>     //реализация
K>    }
K>}

K>public class TemplateT<A> where A : class COperationable
K>{
K>  A DoubleOperation(A arg)
K>  {
K>    return arg.Operation().Operation();
K>  }
K>}

K>...

K>var tt = new TemplateT<Foo>();
K>

K>public interface COperationable<A> { A Operation(A arg); }

K>[Implementation("Foo", "COperationable")]
K>public struct Foo_COperationable : COperation<Foo>
K>{
K>    A Operation(A arg)
K>    {
K>     //реализация
K>    }
K>}

K>[Implicit("CT")]
K>[ClassType("A", "COperationable")]
K>public class TemplateT<A, CT> where CT : COperationable<A>, new()
K>{
K>    static CT ct = new CT();
K>  A DoubleOperation(A arg)
K>  {
K>    return ct.Operation(ct.Operation(ct));
K>  }
K>}

K>...
K>//компилятор подставляет второй неявный параметр,
K>//подбирая соответствующую реализацию для типа Foo из области видимости.
K>var tt = new TemplateT<Foo, Foo_COperationable>();
K>

public class A<B> where B simular String
{
}

public class A2<Arg> where Arg : A<*>
{
}

public DuckWrapper: IDuck
{
  public DuckWrapper(WildDuck duck) {_duck = duck;}
  public IDuck.Quack { _duck.Kryak(); }
}