// This program uses a good balance of generics and inheritance.

using System;


// generic interface for objects that can add.
public interface addable<T>
{
  T add(T y);
}

public class myint : addable<int>
{
   int x;
   public myint(int y) {x=y;}
   public int add(int y) { return x+y; }
   public override string ToString() { return ""+x; }
} // myint


// but what if I have the following class:
public class fraction : addable<fraction>
{
   public int n, d;  // numerator and denominator
   public fraction(int a, int b) {n=a; d=b;}
   public override string ToString() { return n+"/"+d; }
   public fraction add(fraction A)
   { int n = A.n*this.d + this.n*A.d; 
     int d = A.d * this.d;
     return new fraction(n,d);
   }
} // fraction


// generic lists whose members can be added:

public class glist<T> where T : addable<T>
{
   public T car;
   public glist<T> cdr;
   public glist(T a, glist<T> d) {car=a; cdr=d;}
   
   // naturally polymorphic function:
   public int length()
   { int ax = 0;
     for(glist<T> i=this; i!=null; i=i.cdr) ax++;
     return ax;
   }

   // artificially polymorphic function:
   public virtual void print() 
    {Console.WriteLine("how do I know how to print T, what the heck is T?");}

   // not-completely-natural polymorphic function:

   public T sum()
   {
      if (cdr==null) return car; else return car.add(cdr.sum());
   }

} //glist class


// compile to dll with csc /t:library genpolymorph.cs