let f o = o#put

val f : < put : 'a; .. > -> 'a

let f o = 1 + o#put 2 2

val f : < put : int -> int -> int; .. > -> int

J>26    type reader interface {
J>27        Read(b []byte) (ret int, err os.Error)
J>28        String() string
J>29    }
J>

using System.Console;
using System.Diagnostics;

interface INumber[T]
{
  Add(a : T, b : T) : T;
  Sub(a : T, b : T) : T;
}

class IntImpl : INumber[int]
{
  public Add(a : int, b : int) : int { a + b }
  public Sub(a : int, b : int) : int { a - b }
}

class DoubleImpl : INumber[double]
{
  public Add(a : double, b : double) : double { a + b }
  public Sub(a : double, b : double) : double { a - b }
}

[Record]
class Algorithms[T]
{
  _helper : INumber[T];
  
  public Alg1(a : T, b : T, c : T) : T
  {
    _helper.Sub(_helper.Add(a, b), c)
  }
}

module Program
{
  Alg1(a : int,    b : int,    c : int)    : int    { a + b - c }
  Alg1(a : double, b : double, c : double) : double { a + b - c }
  
  Main() : void
  {
    def test[T](f : void -> T, msg : string)
    {
      def timer = Stopwatch.StartNew();
      def res = f();
      def spaces = string(' ', 20 - msg.Length);
      WriteLine($"$msg$spaces took: $(timer.Elapsed) res=$res");
    }
    
    def genericInt()
    {
      def algs = Algorithms(IntImpl());
      mutable res = 0L;
      repeat (100_000_000)
        res += algs.Alg1(42, 8, 49);
      res
    }
    def nongenericInt()
    {
      mutable res = 0L;
      repeat (100_000_000)
        res += Alg1(42, 8, 49);
      res
    }
    def genericDouble()
    {
      def algs = Algorithms(DoubleImpl());
      mutable res = 0.0;
      repeat (100_000_000)
        res += algs.Alg1(42.0, 8.0, 49.0);
      res
    }
    def nongenericDouble()
    {
      mutable res = 0.0;
      repeat (100_000_000)
        res += Alg1(42.0, 8.0, 49.0);
      res
    }
    

    test(nongenericInt,    "nongenericInt");
    test(genericInt,       "genericInt");
    test(nongenericDouble, "nongenericDouble");
    test(genericDouble,    "genericDouble");
  }
}

nongenericInt        took: 00:00:00.1687145 res=100000000
genericInt           took: 00:00:00.7156627 res=100000000
nongenericDouble     took: 00:00:00.1261819 res=100000000
genericDouble        took: 00:00:00.7166952 res=100000000

template <typename T>
void dummy(T t)
{
not_exist_func();
}

int main()
{
}