The.

.gitignore

@@ -13,3 +13,4 @@ replay_pid*
 **/bin/
 .old/
 .metadata/
+**/.classpath

.metadata/.plugins/org.eclipse.core.resources/.history/14/705e7113c9a1001f17dbd629bd636125

@@ -1,5 +0,0 @@
-package abstraction;
-
-public class Main {
-
-}

.metadata/.plugins/org.eclipse.core.resources/.history/16/70edcae5d5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/1a/d0738772d8a2001f13baf1c76b2fe20e

@@ -1,162 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-    boole
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/1c/b05f9b03d6a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return new Cons<A>(a, this);
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/1d/60a430cfd5a2001f13baf1c76b2fe20e

@@ -1,146 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/2/b00c6400c9a1001f17dbd629bd636125

@@ -1,7 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
-org.eclipse.jdt.core.compiler.compliance=21
-org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
-org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
-org.eclipse.jdt.core.compiler.release=enabled
-org.eclipse.jdt.core.compiler.source=21

.metadata/.plugins/org.eclipse.core.resources/.history/25/a084793ad9a2001f13baf1c76b2fe20e

@@ -1,180 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh)
-                        
-                        && t.checkExpect(hh.sort(new Comp(new StrLen())), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp<A> implements IComparator<A> {
-    IEvaluator<A> eval;
-    Comp(IEvaluator<A> eval) {
-        this.eval = eval;
-    }
-    
-    public int compare(A a1, A a2) {
-        return eval.apply(a1) - eval.apply(a2);
-    }
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/27/30da8faad6a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/2d/d09e4d00d7a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/2e/f02da9a8d8a2001f13baf1c76b2fe20e

@@ -1,163 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-    boole
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/2f/70c4a71cc9a1001f17dbd629bd636125

@@ -1,5 +0,0 @@
-package abstraction;
-
-class Examples {
-    
-}

.metadata/.plugins/org.eclipse.core.resources/.history/2f/f0c6b88ed6a2001f13baf1c76b2fe20e

@@ -1,149 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, new Cons<A>(this.first, this.rest));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/3b/00b7d2dcd7a2001f13baf1c76b2fe20e

@@ -1,155 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/3e/b04c2e2a95a6001f1f99f28bbdc62909

@@ -1,131 +0,0 @@
-package fibonacci;
-
-import tester.Tester;
-
-class Examples {
-
-    ISequence<Integer> f;
-    ISequence<String> a;
-    ISeqGen<String> aGen = new AGen();
-
-    void init() {
-        this.f = new Fibonacci();
-        this.a = new GenSeq<String>("", aGen);
-    }
-
-    void testFibonacci(Tester t) {
-        init();
-        t.checkExpect(f.get(), 0);
-        t.checkExpect(f.get(), 1);
-        t.checkExpect(f.get(), 1);
-        t.checkExpect(f.get(), 2);
-        t.checkExpect(f.get(), 3);
-        t.checkExpect(f.get(), 5);
-        t.checkExpect(f.get(), 8);
-    }
-
-    void testASeq(Tester t) {
-        init();
-        t.checkExpect(a.get(), "");
-        t.checkExpect(a.get(), "a");
-        t.checkExpect(a.get(), "aa");
-        t.checkExpect(a.get(), "aaa");
-        t.checkExpect(a.get(), "aaaa");
-        t.checkExpect(a.get(), "aaaaa");
-    }
-}
-
-// A generic list.
-interface ILo<A> {}
-
-class Cons<A> implements ILo<A> {
-
-    A first;
-    ILo<A> rest;
-
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-}
-
-class Mt<A> implements ILo<A> {}
-
-interface ISequence<X> {
-    // Returns the current element in the sequence.
-    // EFFECT: Updates the state to the next element in the sequence.
-    X get();
-}
-
-// Sequence generator method.
-interface ISeqGen<X> {
-    X gen(X state); // Generates the next value in the sequence given the current state.
-}
-
-// The Fibonacci sequence.
-class Fibonacci implements ISequence<Integer> {
-
-    int idx; // Number of times `get()` has been called.
-    int pre; // The previous (last) number.
-    int pen; // The penultimate (second to last) number.
-
-    Fibonacci() {
-        this.pen = 0;
-        this.pre = 1;
-    }
-
-    // Get the next in the sequence.
-    public Integer get() {
-        int ret; // What to return.
-        /*
-
-        idx pen pre ret
-        0   0   1   0
-        1   0   1   1
-        2   1   1   2
-        3   1   2   3
-        4   2   3   5
-        5   3   5   8
-
-        */
-
-        // F(0) = 0; F(1) = 1
-        if (this.idx <= 1) ret = this.idx;
-        else { // F(n) = F(n-1) + F(n-2)
-            ret = this.pre + this.pen;
-
-            this.pen = this.pre;
-            this.pre = ret;
-        }
-
-        this.idx = this.idx + 1;
-        return ret;
-    }
-}
-
-// A generic sequence.
-class GenSeq<X> implements ISequence<X> {
-
-    X state; // The current state of the sequence.
-    ISeqGen<X> seqGen; // The method by which new values are generated.
-
-    // Create new generic sequence given an initial state.
-    GenSeq(X init, ISeqGen<X> seqGen) {
-        this.state = init;
-        this.seqGen = seqGen;
-    }
-
-    public X get() {
-        X ret = this.state;
-        this.state = this.seqGen.gen(this.state);
-        return ret;
-    }
-}
-
-// A string of n "a"s.
-class AGen implements ISeqGen<String> {
-
-    public String gen(String state) {
-        return state.concat("a");
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/3f/70dc808fd7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen(), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/4/c08ee01ad6a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/47/e0575f8ad6a2001f13baf1c76b2fe20e

@@ -1,149 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) == 0) {
-            
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/48/4080d6bbd7a2001f13baf1c76b2fe20e

@@ -1,155 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new hh.CompStr()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/48/d0153d80d7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen(), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/4c/b083956fcaa1001f17dbd629bd636125

@@ -1,94 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-    return new  StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/4d/c086d608d7a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/53/60620459caa1001f17dbd629bd636125

@@ -1,94 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-    return new StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/55/10eba5b6d7a2001f13baf1c76b2fe20e

@@ -1,154 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/56/70843000d8a2001f13baf1c76b2fe20e

@@ -1,155 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/57/907a27f7d8a2001f13baf1c76b2fe20e

@@ -1,176 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp<A> implements IComparator<A> {
-    IEvaluator eval;
-    Comp(IEvaluator eval) {
-        this.eval = eval;
-    }
-    
-    public int compare()
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/58/b07536a6d7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/5b/201de412caa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/5b/408f217bd7a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/5c/c0854747d8a2001f13baf1c76b2fe20e

@@ -1,155 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/5f/203aabc1d6a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/63/00e57d53caa1001f17dbd629bd636125

@@ -1,94 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).apply(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-    return new StringsAfter(new OrderByAlpha()).apply(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/6a/70991c5b19a1001f1cb38ee0d7d0c4d1

@@ -1,7 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
-org.eclipse.jdt.core.compiler.compliance=21
-org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
-org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
-org.eclipse.jdt.core.compiler.release=enabled
-org.eclipse.jdt.core.compiler.source=21

.metadata/.plugins/org.eclipse.core.resources/.history/6b/0061f8dfd7a2001f13baf1c76b2fe20e

@@ -1,155 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/6b/0095a8d8c9a1001f17dbd629bd636125

@@ -1,89 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/70/208ee9e4d5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/73/6069c0c4d6a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) > 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/77/50668705d8a2001f13baf1c76b2fe20e

@@ -1,156 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        ILo<A> newsort = sorted.insertSorted(comp, this.first);
-        return this.rest.sortHelper(comp,  newsort);
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/8/50c70724caa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByAlpha()).apply(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/84/306cebfed5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/86/30b04fa1d6a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/8a/20257291d7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/8a/d0c286a6caa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates an ordering.
-class Disorder {
-    IStringsBefore ordering;
-    
-    Disorder(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new  Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/8c/40db7a00d5a2001f13baf1c76b2fe20e

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates an ordering.
-class Disorder {
-    IStringsBefore ordering;
-    
-    Disorder(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new  Disorder(new OrderByOrderkt hi  ()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/9/70802834caa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/94/00d63222d7a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) <= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/9c/b01fe771d9a2001f13baf1c76b2fe20e

@@ -1,180 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh)
-                        
-                        && t.checkExpect(hh.sort(new Comp<String>(new StrLen())), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp<A> implements IComparator<A> {
-    IEvaluator<A> eval;
-    Comp(IEvaluator<A> eval) {
-        this.eval = eval;
-    }
-    
-    public int compare(A a1, A a2) {
-        return eval.apply(a1) - eval.apply(a2);
-    }
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/a0/1081b6d0d5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/a4/60092434d7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) <= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-        
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/a5/009f4a1ec9a1001f17dbd629bd636125

@@ -1,84 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}
-
-Main.java

.metadata/.plugins/org.eclipse.core.resources/.history/a7/103b2322d6a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) == 0)
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/aa/20b1a633d9a2001f13baf1c76b2fe20e

@@ -1,178 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp<A> implements IComparator<A> {
-    IEvaluator<A> eval;
-    Comp(IEvaluator<A> eval) {
-        this.eval = eval;
-    }
-    
-    public int compare(A a1, A a2) {
-        return eval.apply(a1) - eval.apply(a2);
-    }
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/ae/30548af095a6001f1f99f28bbdc62909

@@ -1,832 +0,0 @@
-package mastermind;
-
-import java.awt.Color;
-import java.awt.Image;
-import java.util.Random;
-import javalib.funworld.*;
-import javalib.worldcanvas.*;
-import javalib.worldimages.*;
-import tester.Tester;
-
-class Examples {
-
-    ILoInt noInt = new MtInt();
-    ILoInt intsOne = new ConsInt(1, new ConsInt(2, new ConsInt(3, noInt)));
-
-    Dot redDot = new Dot(Color.red), greenDot = new Dot(Color.green), blueDot =
-        new Dot(Color.blue), reenDot = new Dot(new Color(255, 255, 0));
-
-    ILoDot noDot = new MtDot(), dotsOne = new ConsDot(
-        redDot,
-        new ConsDot(greenDot, new ConsDot(blueDot, noDot)),
-        new Random(0)
-    ), dotsTwo = new ConsDot(
-        redDot,
-        new ConsDot(blueDot, new ConsDot(blueDot, noDot))
-    ), dotsThree = new ConsDot(
-        reenDot,
-        new ConsDot(reenDot, new ConsDot(reenDot, noDot))
-    ), exampleDotsOne = new ConsDot(
-        redDot,
-        new ConsDot(
-            greenDot,
-            new ConsDot(
-                blueDot,
-                new ConsDot(
-                    greenDot,
-                    new ConsDot(redDot, new ConsDot(greenDot, noDot))
-                )
-            )
-        )
-    ), exampleDotsTwo = new ConsDot(
-        redDot,
-        new ConsDot(
-            blueDot,
-            new ConsDot(
-                greenDot,
-                new ConsDot(
-                    greenDot,
-                    new ConsDot(blueDot, new ConsDot(blueDot, noDot))
-                )
-            )
-        )
-    ), exampleDotsOneNoExact = new ConsDot(
-        greenDot,
-        new ConsDot(blueDot, new ConsDot(redDot, new ConsDot(greenDot, noDot)))
-    ), exampleDotsTwoNoExact = new ConsDot(
-        blueDot,
-        new ConsDot(greenDot, new ConsDot(blueDot, new ConsDot(blueDot, noDot)))
-    );
-
-    Feedback exampleFeedback = new Feedback(2, 2);
-
-    Game exampleGame = new Game();
-
-    boolean testILoDotLen(Tester t) {
-        return t.checkExpect(noDot.len(), 0) && t.checkExpect(dotsOne.len(), 3);
-    }
-
-    boolean testILoDotGetnth(Tester t) {
-        return (
-            t.checkException(
-                new IllegalArgumentException("Index out of bounds."),
-                noDot,
-                "get",
-                1
-            ) &&
-            t.checkException(
-                new IllegalArgumentException("Index out of bounds."),
-                dotsOne,
-                "get",
-                3
-            ) &&
-            t.checkExpect(dotsOne.get(0), redDot) &&
-            t.checkExpect(dotsOne.get(2), blueDot)
-        );
-    }
-
-    boolean testILoDotGen(Tester t) {
-        return (
-            t.checkExpect(noDot.gen(219), noDot) &&
-            t.checkExpect(dotsOne.gen(1), new ConsDot(redDot, noDot)) &&
-            t.checkExpect(
-                dotsOne.gen(3),
-                new ConsDot(
-                    greenDot,
-                    new ConsDot(greenDot, new ConsDot(blueDot, noDot))
-                )
-            )
-        );
-    }
-
-    boolean testILoDotIn(Tester t) {
-        return (
-            t.checkExpect(dotsOne.in(blueDot), true) &&
-            t.checkExpect(noDot.in(redDot), false) &&
-            t.checkExpect(dotsThree.in(blueDot), false)
-        );
-    }
-
-    boolean testILoIntRemove(Tester t) {
-        return (
-            t.checkExpect(
-                intsOne.remove(0),
-                new ConsInt(2, new ConsInt(3, noInt))
-            ) &&
-            t.checkExpect(
-                intsOne.remove(2),
-                new ConsInt(1, new ConsInt(2, noInt))
-            ) &&
-            t.checkException(
-                new IllegalArgumentException(
-                    "Index out of bounds: cannot remove something from nothing."
-                ),
-                intsOne,
-                "remove",
-                3
-            ) &&
-            t.checkException(
-                new IllegalArgumentException(
-                    "Index out of bounds: cannot remove something from nothing."
-                ),
-                noInt,
-                "remove",
-                0
-            ) &&
-            t.checkException(
-                new IllegalArgumentException("Indices must be positive."),
-                intsOne,
-                "remove",
-                -2
-            )
-        );
-    }
-
-    boolean testILoIntLen(Tester t) {
-        return t.checkExpect(intsOne.len(), 3) && t.checkExpect(noInt.len(), 0);
-    }
-
-    boolean testILoIntSubOne(Tester t) {
-        return t.checkExpect(
-            intsOne.subOne(),
-            new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
-        );
-    }
-
-    boolean testILoDotExactIndices(Tester t) {
-        return (
-            t.checkException(
-                new IllegalArgumentException(
-                    "Empty list doesn't exactly match anything."
-                ),
-                noDot,
-                "exactIndices",
-                noDot
-            ) &&
-            t.checkExpect(
-                dotsOne.exactIndices(dotsOne),
-                new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
-            ) &&
-            t.checkExpect(
-                dotsOne.exactIndices(dotsTwo),
-                new ConsInt(0, new ConsInt(2, new MtInt()))
-            )
-        );
-    }
-
-    boolean testILoDotRemove(Tester t) {
-        return (
-            t.checkException(
-                new IllegalArgumentException("Index out of bounds."),
-                noDot,
-                "remove",
-                0
-            ) &&
-            t.checkExpect(
-                dotsOne.remove(0),
-                new ConsDot(greenDot, new ConsDot(blueDot, noDot))
-            ) &&
-            t.checkExpect(
-                dotsTwo.remove(1),
-                new ConsDot(redDot, new ConsDot(blueDot, noDot))
-            )
-        );
-    }
-
-    boolean testILoDotRemoveAll(Tester t) {
-        return (
-            t.checkExpect(dotsOne.removeAll(noInt), dotsOne) &&
-            t.checkExpect(
-                dotsOne.removeAll(
-                    new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
-                ),
-                noDot
-            ) &&
-            t.checkExpect(noDot.removeAll(intsOne), noDot) &&
-            t.checkExpect(
-                dotsTwo.removeAll(new ConsInt(1, new ConsInt(2, noInt))),
-                new ConsDot(redDot, noDot)
-            )
-        );
-    }
-
-    boolean testILoDotCountInexact(Tester t) {
-        return (
-            t.checkExpect(noDot.countInexact(noDot), 0) &&
-            t.checkExpect(dotsOne.countInexact(dotsOne), 3) &&
-            t.checkExpect(
-                exampleDotsOneNoExact.countInexact(exampleDotsTwoNoExact),
-                2
-            )
-        );
-    }
-
-    boolean testILoDotCompare(Tester t) {
-        return (
-            t.checkExpect(
-                exampleDotsOne.compare(exampleDotsTwo),
-                exampleFeedback
-            ) &&
-            t.checkExpect(dotsOne.compare(dotsOne), new Feedback(3, 0))
-        );
-    }
-
-    boolean testDrawMethods(Tester t) {
-        // WorldImage incomplete = new IncompleteGuess(exampleDotsOne).draw();
-        //WorldImage guesses = new ConsGuess(new Guess(dotsOne, new Feedback(1, 2)), new ConsGuess(new Guess(dotsTwo, new Feedback(2, 5)), new MtGuess())).draw();
-        Game game = new Game().addGuess(new Guess(dotsOne, exampleFeedback));
-
-        WorldImage gameImg = game.draw();
-
-        int w = (int) gameImg.getWidth();
-        int h = (int) gameImg.getHeight();
-
-        WorldCanvas c = new WorldCanvas(w, h);
-        WorldScene s = new WorldScene(w, h);
-
-        return game.launch();
-        //c.drawScene(s.placeImageXY(gameImg, w/2, h/2))
-        //c.drawScene(s.placeImageXY(incomplete, (int) (incomplete.getWidth()/2), 100))
-        //c.drawScene(s.placeImageXY(exampleFeedback.draw(), 100, 100))
-        //c.drawScene(s.placeImageXY(redDot.draw(), 100, 100))
-        //c.drawScene(s.placeImageXY(dotsOne.draw(), 250, 250))
-        //&& c.show();
-        //true;
-    }
-}
-
-class Util {
-
-    static int scale = 2;
-    static int fontSz = 24 * scale;
-    static int gapW = 4 * scale; // The gap between objects.
-
-    // Drawing methods.
-    static WorldImage gap = new RectangleImage(
-        gapW,
-        gapW,
-        "outline",
-        new Color(0, 0, 0, 0)
-    );
-
-    static WorldImage pairGap(WorldImage img1, WorldImage img2) {
-        return new BesideAlignImage(AlignModeY.MIDDLE, img1, gap, img2);
-    }
-
-    static WorldImage pairGapAbove(WorldImage img1, WorldImage img2) {
-        return new AboveAlignImage(AlignModeX.CENTER, img1, gap, img2);
-    }
-
-    static WorldImage strPair(String str1, String str2) {
-        return pairGap(
-            new TextImage(str1, fontSz, Color.black),
-            new TextImage(str2, fontSz, Color.black)
-        );
-    }
-
-    static int pairgapW = 2 * 16 * scale + gapW;
-}
-
-// A game state.
-class Game extends World {
-
-    static ILoDot DEFAULTDOTS = new ConsDot(
-        new Dot(Color.RED),
-        new ConsDot(
-            new Dot(Color.GREEN),
-            new ConsDot(new Dot(Color.BLUE), new MtDot())
-        )
-    );
-    static GameConf DEFAULTCONF = new GameConf(true, 5, 5, DEFAULTDOTS);
-
-    GameConf conf; // The game's configuration.
-    ILoDot solution; // The solution to the game.
-    int guessesLeft; // The number of guesses the player has left.
-    ILoGuess guesses; // The guesses the player has taken.
-    boolean done; // Is the game over?
-    boolean won; // Did they player win?
-
-    Game(
-        GameConf conf,
-        ILoDot solution,
-        int guessesLeft,
-        ILoGuess guesses,
-        boolean won,
-        boolean done
-    ) {
-        if (this.won && !this.done) throw new IllegalArgumentException(
-            "Can't win before you've finished playing."
-        );
-        this.conf = conf;
-        this.solution = solution;
-        this.won = won;
-        this.done = done;
-        this.guessesLeft = guessesLeft;
-        this.guesses = guesses;
-    }
-
-    // Convenience constructor using default config and starting values.
-    Game() {
-        this(
-            DEFAULTCONF,
-            DEFAULTCONF.options.gen(DEFAULTCONF.len),
-            DEFAULTCONF.nguesses,
-            new MtGuess(),
-            false,
-            false
-        );
-    }
-
-    public WorldScene makeScene() {
-        WorldScene bg = this.getEmptyScene();
-        WorldImage dot = new Dot(Color.RED).draw();
-        return bg.placeImageXY(
-            dot,
-            (int) dot.getWidth(),
-            (int) dot.getHeight()
-        );
-    }
-
-    boolean launch() {
-        return this.bigBang(100, 100);
-    }
-
-    // Draw the current game state.
-    WorldImage draw() {
-        return new AboveAlignImage(
-            AlignModeX.LEFT,
-            this.draw_sol(),
-            this.draw_guesses(),
-            this.draw_options()
-        );
-    }
-
-    // Draw the solution.
-    WorldImage draw_sol() {
-        if (this.done) return this.draw_sol_rev();
-        else return this.draw_sol_hid();
-    }
-
-    // Draw the revealed answer.
-    WorldImage draw_sol_rev() {
-        return this.solution.draw();
-    }
-
-    // Draw the hidden answer.
-    WorldImage draw_sol_hid() {
-        return new RectangleImage(
-            this.solution.getW(),
-            2 * Dot.r,
-            OutlineMode.SOLID,
-            Color.BLACK
-        );
-    }
-
-    WorldImage draw_guesses() {
-        return this.guesses.draw();
-    }
-
-    WorldImage draw_options() {
-        return this.conf.options.draw();
-    }
-
-    // Convenience methods for testing -- not part of program.
-    Game win() {
-        return new Game(
-            this.conf,
-            this.solution,
-            this.guessesLeft,
-            this.guesses,
-            true,
-            true
-        );
-    }
-
-    Game addGuess(Guess guess) {
-        return new Game(
-            this.conf,
-            this.solution,
-            this.guessesLeft,
-            new ConsGuess(guess, this.guesses),
-            this.won,
-            this.done
-        );
-    }
-}
-
-// A game configuration.
-class GameConf {
-
-    boolean dups; // Whether duplicates are allowed.
-    int len; // The length of the sequence to be guessed.
-    int nguesses; // Number of guesses the player is allowed.
-    ILoDot options; // The dots of which the solution is comprised.
-
-    GameConf(boolean dups, int len, int nguesses, ILoDot options) {
-        if (len <= 0) throw new IllegalArgumentException(
-            "Length of the solution must be greater than 0."
-        );
-        if (nguesses <= 0) throw new IllegalArgumentException(
-            "Must provide the player some guesses."
-        );
-        int oplen = options.len();
-        if (oplen <= 0) throw new IllegalArgumentException(
-            "Must have dot options to guess with."
-        );
-        if (!dups && len > oplen) throw new IllegalArgumentException(
-            "Cant create solution of that length without duplicates."
-        );
-
-        this.dups = dups;
-        this.len = len;
-        this.nguesses = nguesses;
-        this.options = options;
-    }
-}
-
-// A list of guesses.
-interface ILoGuess {
-    WorldImage draw();
-}
-
-class ConsGuess implements ILoGuess {
-
-    Guess guess;
-    ILoGuess nxt;
-
-    ConsGuess(Guess guess, ILoGuess nxt) {
-        this.guess = guess;
-        this.nxt = nxt;
-    }
-
-    public WorldImage draw() {
-        return Util.pairGapAbove(guess.draw(), this.nxt.draw());
-    }
-}
-
-class MtGuess implements ILoGuess {
-
-    public WorldImage draw() {
-        return new EmptyImage();
-    }
-}
-
-// A guess.
-class Guess {
-
-    ILoDot guess; // The dots the user entered.
-    Feedback feedback; // The feedback returned.
-
-    Guess(ILoDot guess, Feedback feedback) {
-        this.guess = guess;
-        this.feedback = feedback;
-    }
-
-    WorldImage draw() {
-        return Util.pairGap(this.guess.draw(), this.feedback.draw());
-    }
-}
-
-// A guess in the midst of being entered.
-class IncompleteGuess {
-
-    ILoDot guessSoFar;
-
-    IncompleteGuess(ILoDot guessSoFar) {
-        this.guessSoFar = guessSoFar;
-    }
-
-    WorldImage draw() {
-        return guessSoFar.draw();
-    }
-}
-
-// Feedback for a guess.
-class Feedback {
-
-    int exact, inexact;
-
-    Feedback(int exact, int inexact) {
-        this.exact = exact;
-        this.inexact = inexact;
-    }
-
-    Feedback add(Feedback other) {
-        int otherExact = other.exact, otherInexact = other.inexact;
-
-        return new Feedback(
-            this.exact + otherExact,
-            this.inexact + otherInexact
-        );
-    }
-
-    WorldImage draw() {
-        return Util.strPair(
-            String.valueOf(this.exact),
-            String.valueOf(this.exact)
-        );
-    }
-}
-
-// A list of dots.
-interface ILoDot {
-    int len(); // Get length.
-    Dot get(int n); // Get nth element.
-    ILoDot remove(int n); // Remove nth element.
-    ILoDot removeAll(ILoInt indices); // Remove element at each index.
-    ILoDot gen(int n); // Generate randomized list.
-
-    boolean match(Color col); // Do the colors match?
-    boolean in(Dot dot); // Is the dot in here?
-
-    Feedback compare(ILoDot other); // Compare two lists & give feedback.
-    ILoInt exactIndices(ILoDot other); // Get indices of exact matches.
-    ILoInt exactIndicesHelper(ILoDot other, int i);
-    int countInexact(ILoDot other); // Get the number of inexact matches. Must be fed exact match-free lists to be accurate.
-    int countInexactHelper(ILoDot other, ILoDot seen);
-
-    WorldImage draw(); // Draw the dots.
-    int getW(); // Get the total width, in pixels, of the list.
-}
-
-class ConsDot implements ILoDot {
-
-    Random rand;
-    Dot dot;
-    ILoDot nxt;
-
-    ConsDot(Dot dot, ILoDot nxt, Random rand) {
-        this.rand = rand;
-        this.dot = dot;
-        this.nxt = nxt;
-    }
-
-    ConsDot(Dot dot, ILoDot nxt) {
-        this(dot, nxt, new Random());
-    }
-
-    public ILoDot gen(int n) {
-        return n <= 0
-            ? new MtDot()
-            : new ConsDot(
-                this.get(this.rand.nextInt(this.len())),
-                this.gen(n - 1)
-            );
-    }
-
-    public Dot get(int n) {
-        if (n == 0) return this.dot;
-        else return this.nxt.get(n - 1);
-    }
-
-    public boolean in(Dot dot) {
-        return dot.equals(this.dot) || this.nxt.in(dot);
-    }
-
-    public int len() {
-        return 1 + this.nxt.len();
-    }
-
-    public boolean match(Color col) {
-        return col.equals(this.dot.c);
-    }
-
-    public WorldImage draw() {
-        return new BesideAlignImage(
-            AlignModeY.PINHOLE,
-            this.dot.draw(),
-            Util.gap,
-            this.nxt.draw()
-        );
-    }
-
-    public int getW() {
-        return this.len() * Dot.r * 2;
-    }
-
-    public Feedback compare(ILoDot other) {
-        if (this.len() != other.len()) throw new IllegalArgumentException(
-            "Cannot compare different lengthed lists."
-        );
-
-        ILoInt exactIndices = this.exactIndices(other);
-
-        ILoDot thisWithoutExact = this.removeAll(exactIndices);
-        ILoDot otherWithoutExact = other.removeAll(exactIndices);
-
-        int exact = exactIndices.len();
-        int inexact = thisWithoutExact.countInexact(otherWithoutExact);
-
-        return new Feedback(exact, inexact);
-    }
-
-    public ILoInt exactIndices(ILoDot other) {
-        return this.exactIndicesHelper(other, 0);
-    }
-
-    public ILoInt exactIndicesHelper(ILoDot other, int i) {
-        // Stop after reaching the end of the list.
-        if (i == this.len()) return new MtInt();
-
-        return this.get(i).equals(other.get(i))
-            ? new ConsInt(i, this.exactIndicesHelper(other, i + 1))
-            : this.exactIndicesHelper(other, i + 1);
-    }
-
-    public int countInexact(ILoDot other) {
-        return this.countInexactHelper(other, new MtDot());
-    }
-
-    public int countInexactHelper(ILoDot other, ILoDot seen) {
-        if (seen.in(this.dot)) {
-            return this.nxt.countInexactHelper(
-                    other,
-                    new ConsDot(this.dot, seen)
-                );
-        }
-
-        return (
-            (other.in(this.dot) ? 1 : 0) +
-            this.nxt.countInexactHelper(other, new ConsDot(this.dot, seen))
-        );
-    }
-
-    public ILoDot remove(int n) {
-        if (n < 0) throw new IllegalArgumentException(
-            "Indices must be positive."
-        );
-
-        if (n == 0) return this.nxt;
-        else return new ConsDot(this.dot, this.nxt.remove(n - 1));
-    }
-
-    public ILoDot removeAll(ILoInt indices) {
-        if (indices.isEmpty()) return this;
-        return this.remove(indices.first()).removeAll(indices.rest().subOne());
-    }
-}
-
-class MtDot implements ILoDot {
-
-    public ILoDot gen(int n) {
-        return new MtDot();
-    }
-
-    public Dot get(int n) {
-        throw new IllegalArgumentException("Index out of bounds.");
-    }
-
-    public int len() {
-        return 0;
-    }
-
-    public WorldImage draw() {
-        return new EmptyImage();
-    }
-
-    public int getW() {
-        return 0;
-    }
-
-    public Feedback compare(ILoDot other) {
-        return new Feedback(0, 0);
-    }
-
-    public boolean match(Color col) {
-        return false;
-    }
-
-    public boolean in(Dot dot) {
-        return false;
-    }
-
-    public ILoInt exactIndices(ILoDot other) {
-        throw new IllegalArgumentException(
-            "Empty list doesn't exactly match anything."
-        );
-    }
-
-    public ILoInt exactIndicesHelper(ILoDot other, int i) {
-        return new MtInt();
-    }
-
-    public int countInexact(ILoDot other) {
-        return 0;
-    }
-
-    public int countInexactHelper(ILoDot other, ILoDot seen) {
-        return 0;
-    }
-
-    public ILoDot remove(int n) {
-        throw new IllegalArgumentException("Index out of bounds.");
-    }
-
-    public ILoDot removeAll(ILoInt indices) {
-        return this;
-    }
-}
-
-// A dot.
-class Dot {
-
-    static int r = 16 * Util.scale;
-    static OutlineMode outlineMode = OutlineMode.SOLID;
-
-    Color c;
-
-    Dot(Color c) {
-        this.c = c;
-    }
-
-    // Draw the dot.
-    WorldImage draw() {
-        return new CircleImage(r, outlineMode, this.c);
-    }
-
-    // Get the width of the dot.
-    int getW() {
-        return 2 * r;
-    }
-}
-
-// A list of integers.
-interface ILoInt {
-    int len(); // Get the length of the list.
-    ILoInt remove(int n); // Remove the nth element of the list.
-    boolean isEmpty(); // Is it empty?
-    int first(); // Get the first value.
-    ILoInt rest(); // Get the rest value.
-    ILoInt subOne(); // Subtract 1 from every int.
-}
-
-class ConsInt implements ILoInt {
-
-    int val;
-    ILoInt nxt;
-
-    ConsInt(int val, ILoInt nxt) {
-        this.val = val;
-        this.nxt = nxt;
-    }
-
-    public int len() {
-        return 1 + this.nxt.len();
-    }
-
-    public ILoInt remove(int n) {
-        if (n < 0) throw new IllegalArgumentException(
-            "Indices must be positive."
-        );
-        return n == 0
-            ? this.nxt
-            : new ConsInt(this.val, this.nxt.remove(n - 1));
-    }
-
-    public boolean isEmpty() {
-        return false;
-    }
-
-    public int first() {
-        return this.val;
-    }
-
-    public ILoInt rest() {
-        return this.nxt;
-    }
-
-    public ILoInt subOne() {
-        return new ConsInt(this.val - 1, this.nxt.subOne());
-    }
-}
-
-class MtInt implements ILoInt {
-
-    public int len() {
-        return 0;
-    }
-
-    public ILoInt remove(int n) {
-        throw new IllegalArgumentException(
-            "Index out of bounds: cannot remove something from nothing."
-        );
-    }
-
-    public boolean isEmpty() {
-        return true;
-    }
-
-    public int first() {
-        throw new IllegalArgumentException(
-            "Cannot get first element in a list without any."
-        );
-    }
-
-    public ILoInt rest() {
-        throw new IllegalArgumentException("Cannot get rest of empty list.");
-    }
-
-    public ILoInt subOne() {
-        return this;
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b0/8099c438caa5001f1d5fac7c5024adb1

@@ -1,7 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
-org.eclipse.jdt.core.compiler.compliance=21
-org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
-org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
-org.eclipse.jdt.core.compiler.release=enabled
-org.eclipse.jdt.core.compiler.source=21

.metadata/.plugins/org.eclipse.core.resources/.history/b0/b07254e5c9a1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b1/20e416e9d5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello))));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b1/6045e1f2d8a2001f13baf1c76b2fe20e

@@ -1,174 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp implements IComparator<String> {
-    IEvaluator eval;
-    Comp(IEvaluator eval) {
-        this.eval = eval;
-    }
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b1/90319d7cbda2001f15f3ea04fc682a70

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates an ordering.
-class Disorder {
-    IStringsBefore ordering;
-    
-    Disorder(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new  Disorder(new OrderByOrder()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b4/509e7e76caa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new  StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b5/d0dd3cd3d5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b7/00975a60d8a2001f13baf1c76b2fe20e

@@ -1,160 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/b8/606810c5c9a1001f17dbd629bd636125

@@ -1,82 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/bc/3035bce4d8a2001f13baf1c76b2fe20e

@@ -1,166 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/bc/b0f4c33ecaa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsBefore(new OrderByShortness()).apply(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/c5/007f5fdad5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/cd/b0dff607d8a2001f13baf1c76b2fe20e

@@ -1,156 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        ILo<A> newsort = sorted.insertSorted(comp, this.first);
-        return this.rest.sortHelper(comp,  sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/db/c051ac7fcaa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new  Disorder(new OrderByAlpha()).after(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/df/20e4d12e95a6001f1f99f28bbdc62909

@@ -1,130 +0,0 @@
-package fibonacci;
-
-import tester.Tester;
-
-class Examples {
-
-    ISequence<Integer> f;
-    ISequence<String> a;
-    ISeqGen<String> aGen = new AGen();
-
-    void init() {
-        this.f = new Fibonacci();
-        this.a = new GenSeq<String>("", aGen);
-    }
-
-    void testFibonacci(Tester t) {
-        init();
-        t.checkExpect(f.get(), 0);
-        t.checkExpect(f.get(), 1);
-        t.checkExpect(f.get(), 1);
-        t.checkExpect(f.get(), 2);
-        t.checkExpect(f.get(), 3);
-        t.checkExpect(f.get(), 5);
-        t.checkExpect(f.get(), 8);
-    }
-
-    void testASeq(Tester t) {
-        init();
-        t.checkExpect(a.get(), "");
-        t.checkExpect(a.get(), "a");
-        t.checkExpect(a.get(), "aa");
-        t.checkExpect(a.get(), "aaa");
-        t.checkExpect(a.get(), "aaaa");
-        t.checkExpect(a.get(), "aaaaa");
-    }
-}
-
-// A generic list.
-interface ILo<A> {}
-
-class Cons<A> implements ILo<A> {
-
-    A first;
-    ILo<A> rest;
-
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-}
-
-class Mt<A> implements ILo<A> {}
-
-interface ISequence<X> {
-    // Returns the current element in the sequence.
-    // EFFECT: Updates the state to the next element in the sequence.
-    X get();
-}
-
-// Sequence generator method.
-interface ISeqGen<X> {
-    X gen(X state); // Generates the next value in the sequence given the current state.
-}
-
-// The Fibonacci sequence.
-class Fibonacci implements ISequence<Integer> {
-
-    int idx; // Number of times `get()` has been called.
-    int pre; // The previous (last) number.
-    int pen; // The penultimate (second to last) number.
-
-    Fibonacci() {
-        this.pen = 0;
-        this.pre = 1;
-    }
-
-    // Get the next in the sequence.
-    public Integer get() {
-        int ret; // What to return.
-        /*
-
-        idx pen pre ret
-        0   0   1   0
-        1   0   1   1
-        2   1   1   2
-        3   1   2   3
-        4   2   3   5
-        5   3   5   8
-
-        */
-
-        // F(0) = 0; F(1) = 1
-        if (this.idx <= 1) ret = this.idx;
-        else { // F(n) = F(n-1) + F(n-2)
-            ret = this.pre + this.pen;
-
-            this.pen = this.pre;
-            this.pre = ret;
-        }
-
-        this.idx = this.idx + 1;
-        return ret;
-    }
-}
-
-// A generic sequence.
-class GenSeq<X> implements ISequence<X> {
-
-    X state; // The current state of the sequence.
-    ISeqGen<X> seqGen; // The method by which new values are generated.
-
-    // Create new generic sequence given an initial state.
-    GenSeq(X init, ISeqGen<X> seqGen) {
-        this.state = init;
-        this.seqGen = seqGen;
-    }
-
-    public X get() {
-        X ret = this.state;
-        this.state = this.seqGen.gen(this.state);
-        return ret;
-    }
-}
-
-// A string of n "a"s.
-class AGen implements ISeqGen<String> {
-
-    public String gen(String state) {
-        return state.concat("a");
-    }}

.metadata/.plugins/org.eclipse.core.resources/.history/df/d0a5984dcaa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).apply(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/e/c0b41b9bd6a2001f13baf1c76b2fe20e

@@ -1,149 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) >= 0) {
-            return new Cons<A>(a, this);
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/e1/a0052e21d6a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first))
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/e4/f0f0a1ead5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello))));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/e6/00802f0bd9a2001f13baf1c76b2fe20e

@@ -1,176 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
-    ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
-    ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-    boolean testILoSort(Tester t) {
-        return t.checkExpect(h.sort(new CompStrLen()), h)
-                        && t.checkExpect(mstr.sort(new CompStrLen()), mstr)
-                        && t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
-                        && t.checkExpect(hh.sort(new CompStrLen()), h)
-                        
-                        && t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
-                        && t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
-                        && t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}} 
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// Compare strings alphabetically.
-class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.compareTo(s2);
-}}
-
-// Compare the sizes of two things with the given Evaluator.
-class Comp<A> implements IComparator<A> {
-    IEvaluator<A> eval;
-    Comp(IEvaluator<A> eval) {
-        this.eval = eval;
-    }
-    
-    public int compare()
-}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/e7/40be406dcaa1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean after(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByShortness()).after(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return new StringsAfter(new OrderByAlpha()).after(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/ea/f0427239caa1001f17dbd629bd636125

@@ -1,94 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    boolean apply(String s1, String s2) {
-        return ! this.ordering.before(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-    return new StringsBefore(new OrderByShortness()).apply(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/eb/70b55cebd5a2001f13baf1c76b2fe20e

@@ -1,147 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return null;
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/ee/20654556caa5001f1d5fac7c5024adb1

@@ -1,5 +0,0 @@
-package fibonacci;
-
-public class Main {
-
-}

.metadata/.plugins/org.eclipse.core.resources/.history/f3/a09bc128d7a2001f13baf1c76b2fe20e

@@ -1,153 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) <= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-        
-        return comp.compare(a, this.first) ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/f5/c04072dfc9a1001f17dbd629bd636125

@@ -1,93 +0,0 @@
-package abstraction;
-
-import tester.Tester;
-
-class Examples {
-    ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
-    
-    boolean tests(Tester t) {
-        return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
-                && t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
-                && t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
-                && t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
-    }
-}
-
-interface IStringsBefore {
-    boolean before(String s1, String s2);
-}
-
-// Negates a IStringsBefore.
-class StringsAfter {
-    IStringsBefore ordering;
-    
-    StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
-    
-    apply(String s1, String s2) {
-        return ! this.ordering(s1, s2);
-    }
-}
-
-class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.length() <= s2.length();
-}}
-
-class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return s1.compareTo(s2) <= 0;
-}}
-
-class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return true;
-}}
-
-class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByShortness().before(s1, s2);
-}}
-
-class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByAlpha().before(s1, s2);
-}}
-
-class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
-    return ! new OrderByOrder().before(s1, s2);
-}}
-
-// A non-empty list of strings.
-interface ILoStrings {
-    String val();                               // Gets the value.
-    String earliest(IStringsBefore ordering);   // Gets the earliest in a list of strings.
-    String earliestHelper(IStringsBefore ordering, String prev);
-}
-
-abstract class ALoStrings implements ILoStrings {
-    String val;
-    
-    ALoStrings(String val) { this.val = val; }
-    
-    public String val() { return this.val; }
-}
-
-class ConsString extends ALoStrings {
-    ILoStrings nxt;
-    
-    ConsString(String val, ILoStrings nxt) {
-        super(val);
-        this.nxt = nxt;
-    }
-    
-    public String earliest(IStringsBefore ordering) {
-        return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
-    }
-    
-    public String earliestHelper(IStringsBefore ordering, String prev) {
-        return new ConsString(prev, this.nxt).earliest(ordering);
-    }
-}
-
-class LastString extends ALoStrings {   
-    LastString(String val) { super(val); }
-    public String earliest(IStringsBefore ordering) { return this.val; }
-    public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
-}

.metadata/.plugins/org.eclipse.core.resources/.history/f9/f0558abfd6a2001f13baf1c76b2fe20e

@@ -1,151 +0,0 @@
-package generics;
-
-import tester.Tester;
-
-class Examples {
-    ILo<Integer> mint = new Mt<Integer>();
-    ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
-    ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
-    
-    ILo<String> mstr = new Mt<String>();
-    ILo<String> hello = new Cons<String>("Hello, ", mstr);
-    ILo<String> world = new Cons<String>("world.", mstr);
-    ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
-    ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
-    ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
-    ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
-    
-    boolean testILoAppend(Tester t) {
-        return t.checkExpect(hello.append(world), helloWorld) &&
-                        t.checkExpect(lint.append(mint), lint) &&
-                        t.checkExpect(mint.append(lint), lint);
-    }
-    
-    boolean testILoArmax(Tester t) {
-        return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
-                        && t.checkExpect(lint2.argmax(new IntSize()), 1)
-                        && t.checkExpect(lint.argmax(new IntSize()), 92);
-    }
-    
-    boolean testILoInsertSorted(Tester t) {
-        return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
-                        && t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
-                        && t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
-    }
-    
-}
-
-// Generic function.
-interface IFunc<X, Y> {
-    Y apply(X input);
-}
-
-// Extracts the value of an input.
-interface IEvaluator<X> extends IFunc<X, Integer> {}
-
-// Calculate the length of a string.
-class StrLen implements IEvaluator<String> { public Integer apply(String input) {
-    return input.length();
-}}
-
-// Calculate the size of an integer.
-class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
-    return input;
-}}
-
-// Compares two values.
-interface IComparator<A> {
-    // Returns a negative number if a1 is "smaller" than a2,
-    // 0 if they are considered equal,
-    // and a positive number of a1 is "bigger" than a2.
-    int compare(A a1, A a2);
-}
-
-// Compare string lengths.
-class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
-    return s1.length() - s2.length();
-}}
-
-// A list of A.
-interface ILo<A> { 
-    // Append a list.
-    ILo<A> append(ILo<A> a);
-    // Find the largest from the evaluator.
-    A argmax(IEvaluator<A> eval);
-    A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
-    // Skip this element of the list.
-    ILo<A> skip();
-    // Sort the list with the comparator.
-    ILo<A> sort(IComparator<A> comp);
-    ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
-    // Add an element to the correct place in a sorted list.
-    ILo<A> insertSorted(IComparator<A> comp, A a);
-}
-
-class Cons<A> implements ILo<A> {
-    A first;
-    ILo<A> rest;
-    
-    Cons(A first, ILo<A> rest) {
-        this.first = first;
-        this.rest = rest;
-    }
-    
-    public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
-    
-    public A argmax(IEvaluator<A> eval) {        
-        return argmaxHelper(eval, this.first, eval.apply(this.first));
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        A now = this.first;
-        Integer nowVal = eval.apply(now);
-        
-        return prevVal >= nowVal ?
-            this.rest.argmaxHelper(eval, prev, prevVal) :
-            this.rest.skip().argmaxHelper(eval, now, nowVal);
-    };
-    
-    public ILo<A> skip() {
-        return this.rest;
-    }
-    
-    public ILo<A> sort(IComparator<A> comp) {
-        return null;
-    }
-    
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return null;
-    }
-    
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        if (comp.compare(a, this.first) <= 0) {
-            return new Cons<A>(a, this);
-        } else {
-            return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
-        }
-    }
-}
-
-class Mt<A> implements ILo<A> {
-    public ILo<A> append(ILo<A> a) { return a; }
-    public A argmax(IEvaluator<A> eval) {
-        throw new UnsupportedOperationException("No max of empty list.");
-    }
-    
-    public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
-        return prev;
-    }
-    
-    public ILo<A> skip() { return this; }
-    
-    public ILo<A> sort(IComparator<A> comp) { return this; }
-    public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
-        return sorted;
-    }
-    public ILo<A> insertSorted(IComparator<A> comp, A a) {
-        return new Cons<A>(a, this);
-    }
-}

.metadata/.plugins/org.eclipse.core.resources/.projects/abstraction/org.eclipse.egit.core/GitProjectData.properties

@@ -1,3 +1,3 @@
 #GitProjectData
-#Wed Nov 13 09:09:56 EST 2024
+#Thu Nov 21 00:04:34 EST 2024
 .gitdir=../.git

.metadata/.plugins/org.eclipse.core.resources/.projects/accumulators/org.eclipse.egit.core/GitProjectData.properties

@@ -1,3 +1,3 @@
 #GitProjectData
-#Tue Nov 05 15:25:59 EST 2024
+#Thu Nov 21 00:04:34 EST 2024
 .gitdir=../.git

.metadata/.plugins/org.eclipse.core.resources/.projects/fibonacci/org.eclipse.egit.core/GitProjectData.properties

@@ -1,3 +1,3 @@
 #GitProjectData
-#Mon Nov 18 11:29:02 EST 2024
+#Thu Nov 21 00:04:34 EST 2024
 .gitdir=../.git

.metadata/.plugins/org.eclipse.core.resources/.projects/generics/org.eclipse.egit.core/GitProjectData.properties

@@ -1,3 +1,3 @@
 #GitProjectData
-#Tue Nov 12 12:12:54 EST 2024
+#Thu Nov 21 00:04:34 EST 2024
 .gitdir=../.git