The.

.gitignore

@@ -11,5 +11,5 @@
 hs_err_pid*
 replay_pid*
 **/bin/
-.metadata/
 .old/
+.metadata/

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

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

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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,163 @@
+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

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

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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,154 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,178 @@
+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

@@ -0,0 +1,832 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,174 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,160 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,149 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,147 @@
+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

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

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

@@ -0,0 +1,153 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,151 @@
+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

@@ -0,0 +1,3 @@
+#GitProjectData
+#Wed Nov 13 09:09:56 EST 2024
+.gitdir=../.git

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

@@ -0,0 +1,3 @@
+#GitProjectData
+#Tue Nov 05 15:25:59 EST 2024
+.gitdir=../.git

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

@@ -0,0 +1,3 @@
+#GitProjectData
+#Mon Nov 18 11:29:02 EST 2024
+.gitdir=../.git