Added Abstraction.

abstraction/.classpath

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-21">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="/home/jacob/School/CS3/libs/javalib.jar"/>
+	<classpathentry kind="lib" path="/home/jacob/School/CS3/libs/tester.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

abstraction/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>abstraction</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

abstraction/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

abstraction/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=21
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+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

abstraction/src/abstraction/Main.java

@@ -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; }
+}