/* simplified, unbounded polymorphic lists, 
   higher-ordered and inlined functions
*/

interface list<T>
{
  int length();
  void map(function<T,T> visitor);
}

interface function<A,B>
{
   B f(A x);
}


class nil<T> implements list<T>
{
  public int length() { return 0; }
  public void map(function<T,T> visitor)
  {/* do nothing */}
}

class cons<T> implements list<T>
{
   private T head;
   private list<T> tail;
   public cons(T h, list<T> tl) { head=h; tail=tl; }
   public T car() { return head; }
   public list<T> cdr() { return tail; }

   public int length() { return 1+tail.length(); }
   public void map(function<T,T> visitor)
   {  
      head = visitor.f(head);
      tail.map(visitor);
   }
}

public class pepperoni
{
  public static void main(String[] args)
  {
    list<int> l = new cons(2,new cons(3,new cons(5,new cons(7,new nil()))));
    list<String> s = new cons("ab",new cons("cd",new nil()));
    System.out.println("length is "+l.length());

    function<int,int> f1, f2;
    function<String,String> g1;

    f1 = new function<int,int>()
    { 
       private int u;
       public int f(int x) { return x+1; }
    };

    f2 = new function<int,int>()
    {
       public int f(int x) { return x*x; }
    };
    
    g1 = new function<String,String>()
    {
       public String f(String x) { return x+x; }
    };

    function<int,int> printer = new function<int,int>()
    {
       public int f(int x) 
        {
           System.out.println(x);
           return x;
        }
    };

    l.map(f1);
    l.map(printer);
    System.out.println("-----");
    l.map(f2);
    s.map(g1);
    l.map(printer);
  }
}

/* 
Recall that we tried the "map" trick before - with C# delegates.  The
problem was that delegates were not parametrically typed - so the
"visitor" had to be defined as having type (object)->object.  This
entailed that it had to explicitly check the runtime type tags of
everything it visited, as well as type cast to/from the object
superclass.
*/