// some silly classes for our list elements
class A {
  void m1() { System.out.println("a1"); }
}
class B extends A {
  void m1() { System.out.println("b1"); }
  void m2() { System.out.println("b2"); }
}  

// version one: subtyping
class ListSub {
  Object hd;
  ListSub tl;
  ListSub(Object hd, ListSub tl) {
    this.hd = hd;
    this.tl = tl;
  }
  static ListSub copy(ListSub src) { // a while also works
    if(src.tl==null)
      return new ListSub(src.hd,null);
    return new ListSub(src.hd, copy(src.tl));
  }
}

class ClientSub {
  public static void main(String[] args) {
    ListSub lstB = new ListSub(new B(), new ListSub(new B(), null));
    ListSub lstA = new ListSub(new A(), ListSub.copy(lstB));
    System.out.println("---");
    for(ListSub l=lstB; l!=null; l = l.tl)
      ((B)l.hd).m1();
    System.out.println("---");
    for(ListSub l=lstA; l!=null; l = l.tl)
      ((A)l.hd).m1();
    System.out.println("---");
    for(ListSub l=lstB; l!=null; l = l.tl)
      ((A)l.hd).m1();
    System.out.println("---");
    for(ListSub l=lstA; l!=null; l = l.tl)
      ((B)l.hd).m1(); // run-time ClassCastException
    System.out.println("---");
  }
}

// version two: parametric polymorphism 

class ListPoly<T> {
  T hd;
  ListPoly<T> tl;
  ListPoly(T hd, ListPoly<T> tl) {
    this.hd = hd;
    this.tl = tl;
  }
  static <T> ListPoly<T> copy(ListPoly<T> src) { // a while also works
    if(src.tl==null)
      return new ListPoly<T>(src.hd,null);
    return new ListPoly<T>(src.hd, copy(src.tl));
  }
}

class ClientPoly {
  public static void main(String[] args) {
    ListPoly<B> lstB = new ListPoly<B>(new B(), new ListPoly<B>(new B(), null));

    // this does not type-check (look at copy's type)!
    // ListPoly<A> lstA = new ListPoly<A>(new A(),  ListPoly.copy<B>(lstB));

    // this happens to work because Java does not actually check things
    // at run-time -- but it really is "wrong", get a warning at least
    // and it is bad style (you are casting around the polymorphism)
    ListPoly<A> lstA = new ListPoly(new A(), ListPoly.<B>copy(lstB));

    // lstB = lstA -- no type-check, elements don't have m2
    // lstA = lstB -- no type-check, allows mutating elements not to have m2
    System.out.println("---");
    for(ListPoly<B> l=lstB; l!=null; l = l.tl)
      l.hd.m1(); // no cast needed
    System.out.println("---");
    for(ListPoly<A> l=lstA; l!=null; l = l.tl)
      l.hd.m1();
    System.out.println("---");
    //for(ListPoly<A> l=lstB; l!=null; l = l.tl)  // no type-check
    //  l.hd.m1();
    //System.out.println("---");
    //for(ListPoly<B> l=lstA; l!=null; l = l.tl) // no type-check
    //  l.hd.m1(); 
    //System.out.println("---");
  }
}

// version three: combining the two ("bounded polymorphism")
//  whole point is copy can return a list whose elements are a 
//  supertype of the argument list's elements

class ListBounded<T> {
  T hd;
  ListBounded<T> tl;
  ListBounded(T hd, ListBounded<T> tl) {
    this.hd = hd;
    this.tl = tl;
  }
  static <S, T extends S> ListBounded<S> copy(ListBounded<T> src) { 
    if(src.tl==null)
      return new ListBounded<S>(src.hd,null);
    return new ListBounded<S>(src.hd, 
                              ListBounded.<S,T>copy(src.tl));
  }
}

class ClientBounded {
  public static void main(String[] args) {
    ListBounded<B> lstB = 
      new ListBounded<B>(new B(), new ListBounded<B>(new B(), null));

    // this type-checks now!
    ListBounded<A> lstA = 
      new ListBounded<A>(new A(),ListBounded.<A,B>copy(lstB));

    // lstB = lstA -- no type-check, elements don't have m2
    // lstA = lstB -- no type-check, allows mutating elements not to have m2
    System.out.println("---");
    for(ListBounded<B> l=lstB; l!=null; l = l.tl)
      l.hd.m1(); // no cast needed
    System.out.println("---");
    for(ListBounded<A> l=lstA; l!=null; l = l.tl)
      l.hd.m1();
    System.out.println("---");
  }
}