import java.util.function.*;
/*
interface Comparable<T> {
  int compareTo(T x);
}

interface Function<A,B> {
  B apply(A x);
}

interface Consumer<A> {
  void accept(A);
}

interface Supplier<A> {
  A get();
}

Function<Integer,Double> f = x -> Math.sqrt(x); // can instantiate with lambda
*/

class person implements Comparable<person>
{
    public String name;
    public int compareTo(person x) {return name.compareTo(x.name);}
}

class student extends person implements Comparable<person>
{
    public double gpa;
    // boring stuff skipped

    // How is the compareTo method be inherited?
}


//class Sorter<T extends Comparable<T>> // older form
class Sorter<T extends Comparable<? super T>> // since jdk 1.8 
{
    void bubblesort(T[] A) // bubble sorts (pointer to) array A 
    {
        for(int i=0;i<A.length-1;i++)
            for(int k=0;i<A.length-1;k++)
                if (A[k].compareTo(A[k+1])>0) {
                    T tmp = A[k]; A[k]=A[k+1]; A[k+1]=tmp; //swap
                }// not efficient but that's not the point here
    }//bubblesort

    static <A,B,C> Function<A,C> compose(Function<? super B,? extends C> f,
					 Function<? super A,? extends B> g) {
	return x -> f.apply(g.apply(x));
    }

    static <A> void consume_twice(Consumer<? super A> consumer, A x) {
	consumer.accept(x);
	consumer.accept(x);
    }
    
    static void notreallymain()
    {
	Sorter<student> S = new Sorter<student>(); //compiles with ? super T
	//Sorter<person> S = new Sorter<student>(); //classes never covariant

	Function<Integer,Double> f = x -> Math.sqrt(x);
	Function<Character,Integer> g = x -> (int)x;
	var fog = compose(f,g);
	System.out.println(fog.apply('a'));
	consume_twice(x -> System.out.println(x), "abc");
    }   
}


// what if I try to do a super on a return type?  -- following won't compile
/*
interface D<T>
{
    T f();
    //void f(T x);
}
class DD implements D<DD>
{
    public DD f() { return null; }
    //public void f(DD x) {}
}
class CC
{
    <T> T g(D<? super T> d) { return d.f(); }
}
*/