///////////////// COMMON TO BOTH CLASS TABLES /////////////////
class Optional extends Object {}
class Some extends Optional {
    Object value;
    Object orElse(Object e){
        return this.value;
    }
}
class None extends Optional {
    Object orElse(Object e){
        return e;
    }
}

class Static extends Object {
    /*
        Makes sure that the input list is a "real" one,
        that is, one created with [] and :: (List and Cons).
        Cannot reduce to any value if not.
    */
    List ensure(List in) {
        return in.isEmpty().ite((List)in,(Cons)in);
    }
}

//////////////// FIRST CLASS TABLE /////////////////
class MinGetter extends Object {
    /*
        Returns the lesser of the two input integers
    */
    Int min(Int a, Int b){
        return a.lt(b).ite(a,b);
    }
    /*
        Returns the minimum of the input list, None if the list is empty.
    */
    Optional listMin(List a) {
        return a.ensureFinite().isEmpty().ite(new None(), new Some(this.min((Int)this.listMin(a.tail).orElse(a.head), a.head)))
    }
}
class Sort extends Object {
    List sort(List in){
        ensure(in).isEmpty().ite(in,minOnStart(in,(Int)((Some)new MinGetter().listMin(in)).value));
    }
    /*
        Put the first occurence of 'min' in 'in' to the start of the list and sort the rest.
    */
    List minOnStart(List in, Int min) {
        return min::this.sort(in.removeFirst(min));
    }
}

///////////////// SECOND CLASS TABLE /////////////////
class MaxGetter extends Object {
    /*
        Returns the bigger of the two input integers
    */
    Int max(Int a, Int b){
        return a.gt(b).ite(a,b);
    }
    /*
        Returns the maximum of the input list, None if the list is empty
    */
    Optional listMax(List a) {
        return a.ensureFinite().isEmpty().ite(
            new None(), 
            new Some(this.max((Int)this.listMax(a.tail).orElse(a.head), (Int)a.head)))
    }
}

class Sort extends Object {
    
    List sort(List in){
        return this.sortAcc(in, []);
    }
    
    List sortAcc(List in, List acc) {
        ensure(in).isEmpty().ite(acc,maxToEnd(in,((Some)new MaxGetter().listMax(in)).value));
    }
    
    /*
        Removes max from in, applies sortAcc on the new list, and adds max to the accumulator.
    */
    List maxToEnd(List in, Int max) {
        return this.sortAcc(in.removeFirst(max), max::in.removeFirst(max));
    }
}

///////////////// TEST INTERFACE /////////////////¨
// These three lines gives access to Integer construction
Int ()
S (Int)
S <: Int

// These three lines allows line construction
List ()
Cons (List, o)
Cons <: List

// These two lines allows use of the sort function,
// the only one whose implementation differs between the two class tables.
Sort ()
Sort: sort(List)