The.
This commit is contained in:
Binary file not shown.
@@ -1,5 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
public class Main {
|
||||
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,162 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
boole
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,146 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
eclipse.preferences.version=1
|
||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
|
||||
org.eclipse.jdt.core.compiler.compliance=21
|
||||
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
|
||||
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
|
||||
org.eclipse.jdt.core.compiler.release=enabled
|
||||
org.eclipse.jdt.core.compiler.source=21
|
||||
@@ -1,180 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh)
|
||||
|
||||
&& t.checkExpect(hh.sort(new Comp(new StrLen())), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp<A> implements IComparator<A> {
|
||||
IEvaluator<A> eval;
|
||||
Comp(IEvaluator<A> eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public int compare(A a1, A a2) {
|
||||
return eval.apply(a1) - eval.apply(a2);
|
||||
}
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,163 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
boole
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
class Examples {
|
||||
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, new Cons<A>(this.first, this.rest));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,131 +0,0 @@
|
||||
package fibonacci;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
|
||||
ISequence<Integer> f;
|
||||
ISequence<String> a;
|
||||
ISeqGen<String> aGen = new AGen();
|
||||
|
||||
void init() {
|
||||
this.f = new Fibonacci();
|
||||
this.a = new GenSeq<String>("", aGen);
|
||||
}
|
||||
|
||||
void testFibonacci(Tester t) {
|
||||
init();
|
||||
t.checkExpect(f.get(), 0);
|
||||
t.checkExpect(f.get(), 1);
|
||||
t.checkExpect(f.get(), 1);
|
||||
t.checkExpect(f.get(), 2);
|
||||
t.checkExpect(f.get(), 3);
|
||||
t.checkExpect(f.get(), 5);
|
||||
t.checkExpect(f.get(), 8);
|
||||
}
|
||||
|
||||
void testASeq(Tester t) {
|
||||
init();
|
||||
t.checkExpect(a.get(), "");
|
||||
t.checkExpect(a.get(), "a");
|
||||
t.checkExpect(a.get(), "aa");
|
||||
t.checkExpect(a.get(), "aaa");
|
||||
t.checkExpect(a.get(), "aaaa");
|
||||
t.checkExpect(a.get(), "aaaaa");
|
||||
}
|
||||
}
|
||||
|
||||
// A generic list.
|
||||
interface ILo<A> {}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {}
|
||||
|
||||
interface ISequence<X> {
|
||||
// Returns the current element in the sequence.
|
||||
// EFFECT: Updates the state to the next element in the sequence.
|
||||
X get();
|
||||
}
|
||||
|
||||
// Sequence generator method.
|
||||
interface ISeqGen<X> {
|
||||
X gen(X state); // Generates the next value in the sequence given the current state.
|
||||
}
|
||||
|
||||
// The Fibonacci sequence.
|
||||
class Fibonacci implements ISequence<Integer> {
|
||||
|
||||
int idx; // Number of times `get()` has been called.
|
||||
int pre; // The previous (last) number.
|
||||
int pen; // The penultimate (second to last) number.
|
||||
|
||||
Fibonacci() {
|
||||
this.pen = 0;
|
||||
this.pre = 1;
|
||||
}
|
||||
|
||||
// Get the next in the sequence.
|
||||
public Integer get() {
|
||||
int ret; // What to return.
|
||||
/*
|
||||
|
||||
idx pen pre ret
|
||||
0 0 1 0
|
||||
1 0 1 1
|
||||
2 1 1 2
|
||||
3 1 2 3
|
||||
4 2 3 5
|
||||
5 3 5 8
|
||||
|
||||
*/
|
||||
|
||||
// F(0) = 0; F(1) = 1
|
||||
if (this.idx <= 1) ret = this.idx;
|
||||
else { // F(n) = F(n-1) + F(n-2)
|
||||
ret = this.pre + this.pen;
|
||||
|
||||
this.pen = this.pre;
|
||||
this.pre = ret;
|
||||
}
|
||||
|
||||
this.idx = this.idx + 1;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
// A generic sequence.
|
||||
class GenSeq<X> implements ISequence<X> {
|
||||
|
||||
X state; // The current state of the sequence.
|
||||
ISeqGen<X> seqGen; // The method by which new values are generated.
|
||||
|
||||
// Create new generic sequence given an initial state.
|
||||
GenSeq(X init, ISeqGen<X> seqGen) {
|
||||
this.state = init;
|
||||
this.seqGen = seqGen;
|
||||
}
|
||||
|
||||
public X get() {
|
||||
X ret = this.state;
|
||||
this.state = this.seqGen.gen(this.state);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
// A string of n "a"s.
|
||||
class AGen implements ISeqGen<String> {
|
||||
|
||||
public String gen(String state) {
|
||||
return state.concat("a");
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen(), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) == 0) {
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new hh.CompStr()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen(), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,154 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,176 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp<A> implements IComparator<A> {
|
||||
IEvaluator eval;
|
||||
Comp(IEvaluator eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public int compare()
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
return new StringsAfter(new OrderByAlpha()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
eclipse.preferences.version=1
|
||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
|
||||
org.eclipse.jdt.core.compiler.compliance=21
|
||||
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
|
||||
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
|
||||
org.eclipse.jdt.core.compiler.release=enabled
|
||||
org.eclipse.jdt.core.compiler.source=21
|
||||
@@ -1,155 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) > 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
ILo<A> newsort = sorted.insertSorted(comp, this.first);
|
||||
return this.rest.sortHelper(comp, newsort);
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByAlpha()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates an ordering.
|
||||
class Disorder {
|
||||
IStringsBefore ordering;
|
||||
|
||||
Disorder(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates an ordering.
|
||||
class Disorder {
|
||||
IStringsBefore ordering;
|
||||
|
||||
Disorder(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByOrderkt hi ()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) <= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,180 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh)
|
||||
|
||||
&& t.checkExpect(hh.sort(new Comp<String>(new StrLen())), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp<A> implements IComparator<A> {
|
||||
IEvaluator<A> eval;
|
||||
Comp(IEvaluator<A> eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public int compare(A a1, A a2) {
|
||||
return eval.apply(a1) - eval.apply(a2);
|
||||
}
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) <= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,84 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
|
||||
Main.java
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) == 0)
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,178 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp<A> implements IComparator<A> {
|
||||
IEvaluator<A> eval;
|
||||
Comp(IEvaluator<A> eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public int compare(A a1, A a2) {
|
||||
return eval.apply(a1) - eval.apply(a2);
|
||||
}
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,832 +0,0 @@
|
||||
package mastermind;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Image;
|
||||
import java.util.Random;
|
||||
import javalib.funworld.*;
|
||||
import javalib.worldcanvas.*;
|
||||
import javalib.worldimages.*;
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
|
||||
ILoInt noInt = new MtInt();
|
||||
ILoInt intsOne = new ConsInt(1, new ConsInt(2, new ConsInt(3, noInt)));
|
||||
|
||||
Dot redDot = new Dot(Color.red), greenDot = new Dot(Color.green), blueDot =
|
||||
new Dot(Color.blue), reenDot = new Dot(new Color(255, 255, 0));
|
||||
|
||||
ILoDot noDot = new MtDot(), dotsOne = new ConsDot(
|
||||
redDot,
|
||||
new ConsDot(greenDot, new ConsDot(blueDot, noDot)),
|
||||
new Random(0)
|
||||
), dotsTwo = new ConsDot(
|
||||
redDot,
|
||||
new ConsDot(blueDot, new ConsDot(blueDot, noDot))
|
||||
), dotsThree = new ConsDot(
|
||||
reenDot,
|
||||
new ConsDot(reenDot, new ConsDot(reenDot, noDot))
|
||||
), exampleDotsOne = new ConsDot(
|
||||
redDot,
|
||||
new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(
|
||||
blueDot,
|
||||
new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(redDot, new ConsDot(greenDot, noDot))
|
||||
)
|
||||
)
|
||||
)
|
||||
), exampleDotsTwo = new ConsDot(
|
||||
redDot,
|
||||
new ConsDot(
|
||||
blueDot,
|
||||
new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(blueDot, new ConsDot(blueDot, noDot))
|
||||
)
|
||||
)
|
||||
)
|
||||
), exampleDotsOneNoExact = new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(blueDot, new ConsDot(redDot, new ConsDot(greenDot, noDot)))
|
||||
), exampleDotsTwoNoExact = new ConsDot(
|
||||
blueDot,
|
||||
new ConsDot(greenDot, new ConsDot(blueDot, new ConsDot(blueDot, noDot)))
|
||||
);
|
||||
|
||||
Feedback exampleFeedback = new Feedback(2, 2);
|
||||
|
||||
Game exampleGame = new Game();
|
||||
|
||||
boolean testILoDotLen(Tester t) {
|
||||
return t.checkExpect(noDot.len(), 0) && t.checkExpect(dotsOne.len(), 3);
|
||||
}
|
||||
|
||||
boolean testILoDotGetnth(Tester t) {
|
||||
return (
|
||||
t.checkException(
|
||||
new IllegalArgumentException("Index out of bounds."),
|
||||
noDot,
|
||||
"get",
|
||||
1
|
||||
) &&
|
||||
t.checkException(
|
||||
new IllegalArgumentException("Index out of bounds."),
|
||||
dotsOne,
|
||||
"get",
|
||||
3
|
||||
) &&
|
||||
t.checkExpect(dotsOne.get(0), redDot) &&
|
||||
t.checkExpect(dotsOne.get(2), blueDot)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotGen(Tester t) {
|
||||
return (
|
||||
t.checkExpect(noDot.gen(219), noDot) &&
|
||||
t.checkExpect(dotsOne.gen(1), new ConsDot(redDot, noDot)) &&
|
||||
t.checkExpect(
|
||||
dotsOne.gen(3),
|
||||
new ConsDot(
|
||||
greenDot,
|
||||
new ConsDot(greenDot, new ConsDot(blueDot, noDot))
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotIn(Tester t) {
|
||||
return (
|
||||
t.checkExpect(dotsOne.in(blueDot), true) &&
|
||||
t.checkExpect(noDot.in(redDot), false) &&
|
||||
t.checkExpect(dotsThree.in(blueDot), false)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoIntRemove(Tester t) {
|
||||
return (
|
||||
t.checkExpect(
|
||||
intsOne.remove(0),
|
||||
new ConsInt(2, new ConsInt(3, noInt))
|
||||
) &&
|
||||
t.checkExpect(
|
||||
intsOne.remove(2),
|
||||
new ConsInt(1, new ConsInt(2, noInt))
|
||||
) &&
|
||||
t.checkException(
|
||||
new IllegalArgumentException(
|
||||
"Index out of bounds: cannot remove something from nothing."
|
||||
),
|
||||
intsOne,
|
||||
"remove",
|
||||
3
|
||||
) &&
|
||||
t.checkException(
|
||||
new IllegalArgumentException(
|
||||
"Index out of bounds: cannot remove something from nothing."
|
||||
),
|
||||
noInt,
|
||||
"remove",
|
||||
0
|
||||
) &&
|
||||
t.checkException(
|
||||
new IllegalArgumentException("Indices must be positive."),
|
||||
intsOne,
|
||||
"remove",
|
||||
-2
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoIntLen(Tester t) {
|
||||
return t.checkExpect(intsOne.len(), 3) && t.checkExpect(noInt.len(), 0);
|
||||
}
|
||||
|
||||
boolean testILoIntSubOne(Tester t) {
|
||||
return t.checkExpect(
|
||||
intsOne.subOne(),
|
||||
new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotExactIndices(Tester t) {
|
||||
return (
|
||||
t.checkException(
|
||||
new IllegalArgumentException(
|
||||
"Empty list doesn't exactly match anything."
|
||||
),
|
||||
noDot,
|
||||
"exactIndices",
|
||||
noDot
|
||||
) &&
|
||||
t.checkExpect(
|
||||
dotsOne.exactIndices(dotsOne),
|
||||
new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
|
||||
) &&
|
||||
t.checkExpect(
|
||||
dotsOne.exactIndices(dotsTwo),
|
||||
new ConsInt(0, new ConsInt(2, new MtInt()))
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotRemove(Tester t) {
|
||||
return (
|
||||
t.checkException(
|
||||
new IllegalArgumentException("Index out of bounds."),
|
||||
noDot,
|
||||
"remove",
|
||||
0
|
||||
) &&
|
||||
t.checkExpect(
|
||||
dotsOne.remove(0),
|
||||
new ConsDot(greenDot, new ConsDot(blueDot, noDot))
|
||||
) &&
|
||||
t.checkExpect(
|
||||
dotsTwo.remove(1),
|
||||
new ConsDot(redDot, new ConsDot(blueDot, noDot))
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotRemoveAll(Tester t) {
|
||||
return (
|
||||
t.checkExpect(dotsOne.removeAll(noInt), dotsOne) &&
|
||||
t.checkExpect(
|
||||
dotsOne.removeAll(
|
||||
new ConsInt(0, new ConsInt(1, new ConsInt(2, noInt)))
|
||||
),
|
||||
noDot
|
||||
) &&
|
||||
t.checkExpect(noDot.removeAll(intsOne), noDot) &&
|
||||
t.checkExpect(
|
||||
dotsTwo.removeAll(new ConsInt(1, new ConsInt(2, noInt))),
|
||||
new ConsDot(redDot, noDot)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotCountInexact(Tester t) {
|
||||
return (
|
||||
t.checkExpect(noDot.countInexact(noDot), 0) &&
|
||||
t.checkExpect(dotsOne.countInexact(dotsOne), 3) &&
|
||||
t.checkExpect(
|
||||
exampleDotsOneNoExact.countInexact(exampleDotsTwoNoExact),
|
||||
2
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
boolean testILoDotCompare(Tester t) {
|
||||
return (
|
||||
t.checkExpect(
|
||||
exampleDotsOne.compare(exampleDotsTwo),
|
||||
exampleFeedback
|
||||
) &&
|
||||
t.checkExpect(dotsOne.compare(dotsOne), new Feedback(3, 0))
|
||||
);
|
||||
}
|
||||
|
||||
boolean testDrawMethods(Tester t) {
|
||||
// WorldImage incomplete = new IncompleteGuess(exampleDotsOne).draw();
|
||||
//WorldImage guesses = new ConsGuess(new Guess(dotsOne, new Feedback(1, 2)), new ConsGuess(new Guess(dotsTwo, new Feedback(2, 5)), new MtGuess())).draw();
|
||||
Game game = new Game().addGuess(new Guess(dotsOne, exampleFeedback));
|
||||
|
||||
WorldImage gameImg = game.draw();
|
||||
|
||||
int w = (int) gameImg.getWidth();
|
||||
int h = (int) gameImg.getHeight();
|
||||
|
||||
WorldCanvas c = new WorldCanvas(w, h);
|
||||
WorldScene s = new WorldScene(w, h);
|
||||
|
||||
return game.launch();
|
||||
//c.drawScene(s.placeImageXY(gameImg, w/2, h/2))
|
||||
//c.drawScene(s.placeImageXY(incomplete, (int) (incomplete.getWidth()/2), 100))
|
||||
//c.drawScene(s.placeImageXY(exampleFeedback.draw(), 100, 100))
|
||||
//c.drawScene(s.placeImageXY(redDot.draw(), 100, 100))
|
||||
//c.drawScene(s.placeImageXY(dotsOne.draw(), 250, 250))
|
||||
//&& c.show();
|
||||
//true;
|
||||
}
|
||||
}
|
||||
|
||||
class Util {
|
||||
|
||||
static int scale = 2;
|
||||
static int fontSz = 24 * scale;
|
||||
static int gapW = 4 * scale; // The gap between objects.
|
||||
|
||||
// Drawing methods.
|
||||
static WorldImage gap = new RectangleImage(
|
||||
gapW,
|
||||
gapW,
|
||||
"outline",
|
||||
new Color(0, 0, 0, 0)
|
||||
);
|
||||
|
||||
static WorldImage pairGap(WorldImage img1, WorldImage img2) {
|
||||
return new BesideAlignImage(AlignModeY.MIDDLE, img1, gap, img2);
|
||||
}
|
||||
|
||||
static WorldImage pairGapAbove(WorldImage img1, WorldImage img2) {
|
||||
return new AboveAlignImage(AlignModeX.CENTER, img1, gap, img2);
|
||||
}
|
||||
|
||||
static WorldImage strPair(String str1, String str2) {
|
||||
return pairGap(
|
||||
new TextImage(str1, fontSz, Color.black),
|
||||
new TextImage(str2, fontSz, Color.black)
|
||||
);
|
||||
}
|
||||
|
||||
static int pairgapW = 2 * 16 * scale + gapW;
|
||||
}
|
||||
|
||||
// A game state.
|
||||
class Game extends World {
|
||||
|
||||
static ILoDot DEFAULTDOTS = new ConsDot(
|
||||
new Dot(Color.RED),
|
||||
new ConsDot(
|
||||
new Dot(Color.GREEN),
|
||||
new ConsDot(new Dot(Color.BLUE), new MtDot())
|
||||
)
|
||||
);
|
||||
static GameConf DEFAULTCONF = new GameConf(true, 5, 5, DEFAULTDOTS);
|
||||
|
||||
GameConf conf; // The game's configuration.
|
||||
ILoDot solution; // The solution to the game.
|
||||
int guessesLeft; // The number of guesses the player has left.
|
||||
ILoGuess guesses; // The guesses the player has taken.
|
||||
boolean done; // Is the game over?
|
||||
boolean won; // Did they player win?
|
||||
|
||||
Game(
|
||||
GameConf conf,
|
||||
ILoDot solution,
|
||||
int guessesLeft,
|
||||
ILoGuess guesses,
|
||||
boolean won,
|
||||
boolean done
|
||||
) {
|
||||
if (this.won && !this.done) throw new IllegalArgumentException(
|
||||
"Can't win before you've finished playing."
|
||||
);
|
||||
this.conf = conf;
|
||||
this.solution = solution;
|
||||
this.won = won;
|
||||
this.done = done;
|
||||
this.guessesLeft = guessesLeft;
|
||||
this.guesses = guesses;
|
||||
}
|
||||
|
||||
// Convenience constructor using default config and starting values.
|
||||
Game() {
|
||||
this(
|
||||
DEFAULTCONF,
|
||||
DEFAULTCONF.options.gen(DEFAULTCONF.len),
|
||||
DEFAULTCONF.nguesses,
|
||||
new MtGuess(),
|
||||
false,
|
||||
false
|
||||
);
|
||||
}
|
||||
|
||||
public WorldScene makeScene() {
|
||||
WorldScene bg = this.getEmptyScene();
|
||||
WorldImage dot = new Dot(Color.RED).draw();
|
||||
return bg.placeImageXY(
|
||||
dot,
|
||||
(int) dot.getWidth(),
|
||||
(int) dot.getHeight()
|
||||
);
|
||||
}
|
||||
|
||||
boolean launch() {
|
||||
return this.bigBang(100, 100);
|
||||
}
|
||||
|
||||
// Draw the current game state.
|
||||
WorldImage draw() {
|
||||
return new AboveAlignImage(
|
||||
AlignModeX.LEFT,
|
||||
this.draw_sol(),
|
||||
this.draw_guesses(),
|
||||
this.draw_options()
|
||||
);
|
||||
}
|
||||
|
||||
// Draw the solution.
|
||||
WorldImage draw_sol() {
|
||||
if (this.done) return this.draw_sol_rev();
|
||||
else return this.draw_sol_hid();
|
||||
}
|
||||
|
||||
// Draw the revealed answer.
|
||||
WorldImage draw_sol_rev() {
|
||||
return this.solution.draw();
|
||||
}
|
||||
|
||||
// Draw the hidden answer.
|
||||
WorldImage draw_sol_hid() {
|
||||
return new RectangleImage(
|
||||
this.solution.getW(),
|
||||
2 * Dot.r,
|
||||
OutlineMode.SOLID,
|
||||
Color.BLACK
|
||||
);
|
||||
}
|
||||
|
||||
WorldImage draw_guesses() {
|
||||
return this.guesses.draw();
|
||||
}
|
||||
|
||||
WorldImage draw_options() {
|
||||
return this.conf.options.draw();
|
||||
}
|
||||
|
||||
// Convenience methods for testing -- not part of program.
|
||||
Game win() {
|
||||
return new Game(
|
||||
this.conf,
|
||||
this.solution,
|
||||
this.guessesLeft,
|
||||
this.guesses,
|
||||
true,
|
||||
true
|
||||
);
|
||||
}
|
||||
|
||||
Game addGuess(Guess guess) {
|
||||
return new Game(
|
||||
this.conf,
|
||||
this.solution,
|
||||
this.guessesLeft,
|
||||
new ConsGuess(guess, this.guesses),
|
||||
this.won,
|
||||
this.done
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// A game configuration.
|
||||
class GameConf {
|
||||
|
||||
boolean dups; // Whether duplicates are allowed.
|
||||
int len; // The length of the sequence to be guessed.
|
||||
int nguesses; // Number of guesses the player is allowed.
|
||||
ILoDot options; // The dots of which the solution is comprised.
|
||||
|
||||
GameConf(boolean dups, int len, int nguesses, ILoDot options) {
|
||||
if (len <= 0) throw new IllegalArgumentException(
|
||||
"Length of the solution must be greater than 0."
|
||||
);
|
||||
if (nguesses <= 0) throw new IllegalArgumentException(
|
||||
"Must provide the player some guesses."
|
||||
);
|
||||
int oplen = options.len();
|
||||
if (oplen <= 0) throw new IllegalArgumentException(
|
||||
"Must have dot options to guess with."
|
||||
);
|
||||
if (!dups && len > oplen) throw new IllegalArgumentException(
|
||||
"Cant create solution of that length without duplicates."
|
||||
);
|
||||
|
||||
this.dups = dups;
|
||||
this.len = len;
|
||||
this.nguesses = nguesses;
|
||||
this.options = options;
|
||||
}
|
||||
}
|
||||
|
||||
// A list of guesses.
|
||||
interface ILoGuess {
|
||||
WorldImage draw();
|
||||
}
|
||||
|
||||
class ConsGuess implements ILoGuess {
|
||||
|
||||
Guess guess;
|
||||
ILoGuess nxt;
|
||||
|
||||
ConsGuess(Guess guess, ILoGuess nxt) {
|
||||
this.guess = guess;
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public WorldImage draw() {
|
||||
return Util.pairGapAbove(guess.draw(), this.nxt.draw());
|
||||
}
|
||||
}
|
||||
|
||||
class MtGuess implements ILoGuess {
|
||||
|
||||
public WorldImage draw() {
|
||||
return new EmptyImage();
|
||||
}
|
||||
}
|
||||
|
||||
// A guess.
|
||||
class Guess {
|
||||
|
||||
ILoDot guess; // The dots the user entered.
|
||||
Feedback feedback; // The feedback returned.
|
||||
|
||||
Guess(ILoDot guess, Feedback feedback) {
|
||||
this.guess = guess;
|
||||
this.feedback = feedback;
|
||||
}
|
||||
|
||||
WorldImage draw() {
|
||||
return Util.pairGap(this.guess.draw(), this.feedback.draw());
|
||||
}
|
||||
}
|
||||
|
||||
// A guess in the midst of being entered.
|
||||
class IncompleteGuess {
|
||||
|
||||
ILoDot guessSoFar;
|
||||
|
||||
IncompleteGuess(ILoDot guessSoFar) {
|
||||
this.guessSoFar = guessSoFar;
|
||||
}
|
||||
|
||||
WorldImage draw() {
|
||||
return guessSoFar.draw();
|
||||
}
|
||||
}
|
||||
|
||||
// Feedback for a guess.
|
||||
class Feedback {
|
||||
|
||||
int exact, inexact;
|
||||
|
||||
Feedback(int exact, int inexact) {
|
||||
this.exact = exact;
|
||||
this.inexact = inexact;
|
||||
}
|
||||
|
||||
Feedback add(Feedback other) {
|
||||
int otherExact = other.exact, otherInexact = other.inexact;
|
||||
|
||||
return new Feedback(
|
||||
this.exact + otherExact,
|
||||
this.inexact + otherInexact
|
||||
);
|
||||
}
|
||||
|
||||
WorldImage draw() {
|
||||
return Util.strPair(
|
||||
String.valueOf(this.exact),
|
||||
String.valueOf(this.exact)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// A list of dots.
|
||||
interface ILoDot {
|
||||
int len(); // Get length.
|
||||
Dot get(int n); // Get nth element.
|
||||
ILoDot remove(int n); // Remove nth element.
|
||||
ILoDot removeAll(ILoInt indices); // Remove element at each index.
|
||||
ILoDot gen(int n); // Generate randomized list.
|
||||
|
||||
boolean match(Color col); // Do the colors match?
|
||||
boolean in(Dot dot); // Is the dot in here?
|
||||
|
||||
Feedback compare(ILoDot other); // Compare two lists & give feedback.
|
||||
ILoInt exactIndices(ILoDot other); // Get indices of exact matches.
|
||||
ILoInt exactIndicesHelper(ILoDot other, int i);
|
||||
int countInexact(ILoDot other); // Get the number of inexact matches. Must be fed exact match-free lists to be accurate.
|
||||
int countInexactHelper(ILoDot other, ILoDot seen);
|
||||
|
||||
WorldImage draw(); // Draw the dots.
|
||||
int getW(); // Get the total width, in pixels, of the list.
|
||||
}
|
||||
|
||||
class ConsDot implements ILoDot {
|
||||
|
||||
Random rand;
|
||||
Dot dot;
|
||||
ILoDot nxt;
|
||||
|
||||
ConsDot(Dot dot, ILoDot nxt, Random rand) {
|
||||
this.rand = rand;
|
||||
this.dot = dot;
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
ConsDot(Dot dot, ILoDot nxt) {
|
||||
this(dot, nxt, new Random());
|
||||
}
|
||||
|
||||
public ILoDot gen(int n) {
|
||||
return n <= 0
|
||||
? new MtDot()
|
||||
: new ConsDot(
|
||||
this.get(this.rand.nextInt(this.len())),
|
||||
this.gen(n - 1)
|
||||
);
|
||||
}
|
||||
|
||||
public Dot get(int n) {
|
||||
if (n == 0) return this.dot;
|
||||
else return this.nxt.get(n - 1);
|
||||
}
|
||||
|
||||
public boolean in(Dot dot) {
|
||||
return dot.equals(this.dot) || this.nxt.in(dot);
|
||||
}
|
||||
|
||||
public int len() {
|
||||
return 1 + this.nxt.len();
|
||||
}
|
||||
|
||||
public boolean match(Color col) {
|
||||
return col.equals(this.dot.c);
|
||||
}
|
||||
|
||||
public WorldImage draw() {
|
||||
return new BesideAlignImage(
|
||||
AlignModeY.PINHOLE,
|
||||
this.dot.draw(),
|
||||
Util.gap,
|
||||
this.nxt.draw()
|
||||
);
|
||||
}
|
||||
|
||||
public int getW() {
|
||||
return this.len() * Dot.r * 2;
|
||||
}
|
||||
|
||||
public Feedback compare(ILoDot other) {
|
||||
if (this.len() != other.len()) throw new IllegalArgumentException(
|
||||
"Cannot compare different lengthed lists."
|
||||
);
|
||||
|
||||
ILoInt exactIndices = this.exactIndices(other);
|
||||
|
||||
ILoDot thisWithoutExact = this.removeAll(exactIndices);
|
||||
ILoDot otherWithoutExact = other.removeAll(exactIndices);
|
||||
|
||||
int exact = exactIndices.len();
|
||||
int inexact = thisWithoutExact.countInexact(otherWithoutExact);
|
||||
|
||||
return new Feedback(exact, inexact);
|
||||
}
|
||||
|
||||
public ILoInt exactIndices(ILoDot other) {
|
||||
return this.exactIndicesHelper(other, 0);
|
||||
}
|
||||
|
||||
public ILoInt exactIndicesHelper(ILoDot other, int i) {
|
||||
// Stop after reaching the end of the list.
|
||||
if (i == this.len()) return new MtInt();
|
||||
|
||||
return this.get(i).equals(other.get(i))
|
||||
? new ConsInt(i, this.exactIndicesHelper(other, i + 1))
|
||||
: this.exactIndicesHelper(other, i + 1);
|
||||
}
|
||||
|
||||
public int countInexact(ILoDot other) {
|
||||
return this.countInexactHelper(other, new MtDot());
|
||||
}
|
||||
|
||||
public int countInexactHelper(ILoDot other, ILoDot seen) {
|
||||
if (seen.in(this.dot)) {
|
||||
return this.nxt.countInexactHelper(
|
||||
other,
|
||||
new ConsDot(this.dot, seen)
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
(other.in(this.dot) ? 1 : 0) +
|
||||
this.nxt.countInexactHelper(other, new ConsDot(this.dot, seen))
|
||||
);
|
||||
}
|
||||
|
||||
public ILoDot remove(int n) {
|
||||
if (n < 0) throw new IllegalArgumentException(
|
||||
"Indices must be positive."
|
||||
);
|
||||
|
||||
if (n == 0) return this.nxt;
|
||||
else return new ConsDot(this.dot, this.nxt.remove(n - 1));
|
||||
}
|
||||
|
||||
public ILoDot removeAll(ILoInt indices) {
|
||||
if (indices.isEmpty()) return this;
|
||||
return this.remove(indices.first()).removeAll(indices.rest().subOne());
|
||||
}
|
||||
}
|
||||
|
||||
class MtDot implements ILoDot {
|
||||
|
||||
public ILoDot gen(int n) {
|
||||
return new MtDot();
|
||||
}
|
||||
|
||||
public Dot get(int n) {
|
||||
throw new IllegalArgumentException("Index out of bounds.");
|
||||
}
|
||||
|
||||
public int len() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public WorldImage draw() {
|
||||
return new EmptyImage();
|
||||
}
|
||||
|
||||
public int getW() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public Feedback compare(ILoDot other) {
|
||||
return new Feedback(0, 0);
|
||||
}
|
||||
|
||||
public boolean match(Color col) {
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean in(Dot dot) {
|
||||
return false;
|
||||
}
|
||||
|
||||
public ILoInt exactIndices(ILoDot other) {
|
||||
throw new IllegalArgumentException(
|
||||
"Empty list doesn't exactly match anything."
|
||||
);
|
||||
}
|
||||
|
||||
public ILoInt exactIndicesHelper(ILoDot other, int i) {
|
||||
return new MtInt();
|
||||
}
|
||||
|
||||
public int countInexact(ILoDot other) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public int countInexactHelper(ILoDot other, ILoDot seen) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public ILoDot remove(int n) {
|
||||
throw new IllegalArgumentException("Index out of bounds.");
|
||||
}
|
||||
|
||||
public ILoDot removeAll(ILoInt indices) {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
// A dot.
|
||||
class Dot {
|
||||
|
||||
static int r = 16 * Util.scale;
|
||||
static OutlineMode outlineMode = OutlineMode.SOLID;
|
||||
|
||||
Color c;
|
||||
|
||||
Dot(Color c) {
|
||||
this.c = c;
|
||||
}
|
||||
|
||||
// Draw the dot.
|
||||
WorldImage draw() {
|
||||
return new CircleImage(r, outlineMode, this.c);
|
||||
}
|
||||
|
||||
// Get the width of the dot.
|
||||
int getW() {
|
||||
return 2 * r;
|
||||
}
|
||||
}
|
||||
|
||||
// A list of integers.
|
||||
interface ILoInt {
|
||||
int len(); // Get the length of the list.
|
||||
ILoInt remove(int n); // Remove the nth element of the list.
|
||||
boolean isEmpty(); // Is it empty?
|
||||
int first(); // Get the first value.
|
||||
ILoInt rest(); // Get the rest value.
|
||||
ILoInt subOne(); // Subtract 1 from every int.
|
||||
}
|
||||
|
||||
class ConsInt implements ILoInt {
|
||||
|
||||
int val;
|
||||
ILoInt nxt;
|
||||
|
||||
ConsInt(int val, ILoInt nxt) {
|
||||
this.val = val;
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public int len() {
|
||||
return 1 + this.nxt.len();
|
||||
}
|
||||
|
||||
public ILoInt remove(int n) {
|
||||
if (n < 0) throw new IllegalArgumentException(
|
||||
"Indices must be positive."
|
||||
);
|
||||
return n == 0
|
||||
? this.nxt
|
||||
: new ConsInt(this.val, this.nxt.remove(n - 1));
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return false;
|
||||
}
|
||||
|
||||
public int first() {
|
||||
return this.val;
|
||||
}
|
||||
|
||||
public ILoInt rest() {
|
||||
return this.nxt;
|
||||
}
|
||||
|
||||
public ILoInt subOne() {
|
||||
return new ConsInt(this.val - 1, this.nxt.subOne());
|
||||
}
|
||||
}
|
||||
|
||||
class MtInt implements ILoInt {
|
||||
|
||||
public int len() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
public ILoInt remove(int n) {
|
||||
throw new IllegalArgumentException(
|
||||
"Index out of bounds: cannot remove something from nothing."
|
||||
);
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return true;
|
||||
}
|
||||
|
||||
public int first() {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot get first element in a list without any."
|
||||
);
|
||||
}
|
||||
|
||||
public ILoInt rest() {
|
||||
throw new IllegalArgumentException("Cannot get rest of empty list.");
|
||||
}
|
||||
|
||||
public ILoInt subOne() {
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
eclipse.preferences.version=1
|
||||
org.eclipse.jdt.core.compiler.codegen.targetPlatform=21
|
||||
org.eclipse.jdt.core.compiler.compliance=21
|
||||
org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
|
||||
org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
|
||||
org.eclipse.jdt.core.compiler.release=enabled
|
||||
org.eclipse.jdt.core.compiler.source=21
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello))));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,174 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp implements IComparator<String> {
|
||||
IEvaluator eval;
|
||||
Comp(IEvaluator eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates an ordering.
|
||||
class Disorder {
|
||||
IStringsBefore ordering;
|
||||
|
||||
Disorder(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByOrder()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,160 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,166 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsBefore(new OrderByShortness()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,156 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
ILo<A> newsort = sorted.insertSorted(comp, this.first);
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new Disorder(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
package fibonacci;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
|
||||
ISequence<Integer> f;
|
||||
ISequence<String> a;
|
||||
ISeqGen<String> aGen = new AGen();
|
||||
|
||||
void init() {
|
||||
this.f = new Fibonacci();
|
||||
this.a = new GenSeq<String>("", aGen);
|
||||
}
|
||||
|
||||
void testFibonacci(Tester t) {
|
||||
init();
|
||||
t.checkExpect(f.get(), 0);
|
||||
t.checkExpect(f.get(), 1);
|
||||
t.checkExpect(f.get(), 1);
|
||||
t.checkExpect(f.get(), 2);
|
||||
t.checkExpect(f.get(), 3);
|
||||
t.checkExpect(f.get(), 5);
|
||||
t.checkExpect(f.get(), 8);
|
||||
}
|
||||
|
||||
void testASeq(Tester t) {
|
||||
init();
|
||||
t.checkExpect(a.get(), "");
|
||||
t.checkExpect(a.get(), "a");
|
||||
t.checkExpect(a.get(), "aa");
|
||||
t.checkExpect(a.get(), "aaa");
|
||||
t.checkExpect(a.get(), "aaaa");
|
||||
t.checkExpect(a.get(), "aaaaa");
|
||||
}
|
||||
}
|
||||
|
||||
// A generic list.
|
||||
interface ILo<A> {}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {}
|
||||
|
||||
interface ISequence<X> {
|
||||
// Returns the current element in the sequence.
|
||||
// EFFECT: Updates the state to the next element in the sequence.
|
||||
X get();
|
||||
}
|
||||
|
||||
// Sequence generator method.
|
||||
interface ISeqGen<X> {
|
||||
X gen(X state); // Generates the next value in the sequence given the current state.
|
||||
}
|
||||
|
||||
// The Fibonacci sequence.
|
||||
class Fibonacci implements ISequence<Integer> {
|
||||
|
||||
int idx; // Number of times `get()` has been called.
|
||||
int pre; // The previous (last) number.
|
||||
int pen; // The penultimate (second to last) number.
|
||||
|
||||
Fibonacci() {
|
||||
this.pen = 0;
|
||||
this.pre = 1;
|
||||
}
|
||||
|
||||
// Get the next in the sequence.
|
||||
public Integer get() {
|
||||
int ret; // What to return.
|
||||
/*
|
||||
|
||||
idx pen pre ret
|
||||
0 0 1 0
|
||||
1 0 1 1
|
||||
2 1 1 2
|
||||
3 1 2 3
|
||||
4 2 3 5
|
||||
5 3 5 8
|
||||
|
||||
*/
|
||||
|
||||
// F(0) = 0; F(1) = 1
|
||||
if (this.idx <= 1) ret = this.idx;
|
||||
else { // F(n) = F(n-1) + F(n-2)
|
||||
ret = this.pre + this.pen;
|
||||
|
||||
this.pen = this.pre;
|
||||
this.pre = ret;
|
||||
}
|
||||
|
||||
this.idx = this.idx + 1;
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
// A generic sequence.
|
||||
class GenSeq<X> implements ISequence<X> {
|
||||
|
||||
X state; // The current state of the sequence.
|
||||
ISeqGen<X> seqGen; // The method by which new values are generated.
|
||||
|
||||
// Create new generic sequence given an initial state.
|
||||
GenSeq(X init, ISeqGen<X> seqGen) {
|
||||
this.state = init;
|
||||
this.seqGen = seqGen;
|
||||
}
|
||||
|
||||
public X get() {
|
||||
X ret = this.state;
|
||||
this.state = this.seqGen.gen(this.state);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
// A string of n "a"s.
|
||||
class AGen implements ISeqGen<String> {
|
||||
|
||||
public String gen(String state) {
|
||||
return state.concat("a");
|
||||
}}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,149 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) >= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first))
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello))));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,176 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
ILo<String> hh = new Cons<String>("hh", new Cons<String>("hhhh", new Cons<String>("h", mstr)));
|
||||
ILo<String> hhh = new Cons<String>("a", new Cons<String>("b", new Cons<String>("c", mstr)));
|
||||
ILo<String> hhhh = new Cons<String>("b", new Cons<String>("a", new Cons<String>("c", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
boolean testILoSort(Tester t) {
|
||||
return t.checkExpect(h.sort(new CompStrLen()), h)
|
||||
&& t.checkExpect(mstr.sort(new CompStrLen()), mstr)
|
||||
&& t.checkExpect(helloWorld.sort(new CompStrLen()), new Cons<String>("world.", new Cons<String>("Hello, ", mstr)))
|
||||
&& t.checkExpect(hh.sort(new CompStrLen()), h)
|
||||
|
||||
&& t.checkExpect(mstr.sort(new CompStrAlp()), mstr)
|
||||
&& t.checkExpect(hhh.sort(new CompStrAlp()), hhh)
|
||||
&& t.checkExpect(hhhh.sort(new CompStrAlp()), hhh);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// Compare strings alphabetically.
|
||||
class CompStrAlp implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.compareTo(s2);
|
||||
}}
|
||||
|
||||
// Compare the sizes of two things with the given Evaluator.
|
||||
class Comp<A> implements IComparator<A> {
|
||||
IEvaluator<A> eval;
|
||||
Comp(IEvaluator<A> eval) {
|
||||
this.eval = eval;
|
||||
}
|
||||
|
||||
public int compare()
|
||||
}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return this.rest.sortHelper(comp, new Cons<A>(this.first, new Mt<A>()));
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return this.rest.sortHelper(comp, sorted.insertSorted(comp, this.first));
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return comp.compare(a, this.first) <= 0 ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean after(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByShortness()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return new StringsAfter(new OrderByAlpha()).after(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
boolean apply(String s1, String s2) {
|
||||
return ! this.ordering.before(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
return new StringsBefore(new OrderByShortness()).apply(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,147 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello)));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
package fibonacci;
|
||||
|
||||
public class Main {
|
||||
|
||||
}
|
||||
@@ -1,153 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) <= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
|
||||
return comp.compare(a, this.first) ? new Cons<A>(a ,this) : new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
package abstraction;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILoStrings someWords = new ConsString("feldspar", new ConsString("assignment", new ConsString("curb", new LastString("carpet"))));
|
||||
|
||||
boolean tests(Tester t) {
|
||||
return t.checkExpect(someWords.earliest(new OrderByShortness()), "curb")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByAlpha()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByOrder()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByLongness()), "assignment")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByUnalpha()), "feldspar")
|
||||
&& t.checkExpect(someWords.earliest(new OrderByDisorder()), "carpet");
|
||||
}
|
||||
}
|
||||
|
||||
interface IStringsBefore {
|
||||
boolean before(String s1, String s2);
|
||||
}
|
||||
|
||||
// Negates a IStringsBefore.
|
||||
class StringsAfter {
|
||||
IStringsBefore ordering;
|
||||
|
||||
StringsAfter(IStringsBefore ordering) { this.ordering = ordering; }
|
||||
|
||||
apply(String s1, String s2) {
|
||||
return ! this.ordering(s1, s2);
|
||||
}
|
||||
}
|
||||
|
||||
class OrderByShortness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.length() <= s2.length();
|
||||
}}
|
||||
|
||||
class OrderByAlpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return s1.compareTo(s2) <= 0;
|
||||
}}
|
||||
|
||||
class OrderByOrder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return true;
|
||||
}}
|
||||
|
||||
class OrderByLongness implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByShortness().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByUnalpha implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByAlpha().before(s1, s2);
|
||||
}}
|
||||
|
||||
class OrderByDisorder implements IStringsBefore { public boolean before(String s1, String s2) {
|
||||
return ! new OrderByOrder().before(s1, s2);
|
||||
}}
|
||||
|
||||
// A non-empty list of strings.
|
||||
interface ILoStrings {
|
||||
String val(); // Gets the value.
|
||||
String earliest(IStringsBefore ordering); // Gets the earliest in a list of strings.
|
||||
String earliestHelper(IStringsBefore ordering, String prev);
|
||||
}
|
||||
|
||||
abstract class ALoStrings implements ILoStrings {
|
||||
String val;
|
||||
|
||||
ALoStrings(String val) { this.val = val; }
|
||||
|
||||
public String val() { return this.val; }
|
||||
}
|
||||
|
||||
class ConsString extends ALoStrings {
|
||||
ILoStrings nxt;
|
||||
|
||||
ConsString(String val, ILoStrings nxt) {
|
||||
super(val);
|
||||
this.nxt = nxt;
|
||||
}
|
||||
|
||||
public String earliest(IStringsBefore ordering) {
|
||||
return ordering.before(this.val, this.nxt.val()) ? this.nxt.earliestHelper(ordering, this.val) : this.nxt.earliest(ordering);
|
||||
}
|
||||
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) {
|
||||
return new ConsString(prev, this.nxt).earliest(ordering);
|
||||
}
|
||||
}
|
||||
|
||||
class LastString extends ALoStrings {
|
||||
LastString(String val) { super(val); }
|
||||
public String earliest(IStringsBefore ordering) { return this.val; }
|
||||
public String earliestHelper(IStringsBefore ordering, String prev) { return prev; }
|
||||
}
|
||||
@@ -1,151 +0,0 @@
|
||||
package generics;
|
||||
|
||||
import tester.Tester;
|
||||
|
||||
class Examples {
|
||||
ILo<Integer> mint = new Mt<Integer>();
|
||||
ILo<Integer> lint = new Cons<Integer>(1, new Cons<Integer>(92, new Cons<Integer>(-12, mint)));
|
||||
ILo<Integer> lint2 = new Cons<Integer>(1, new Cons<Integer>(1, mint));
|
||||
|
||||
ILo<String> mstr = new Mt<String>();
|
||||
ILo<String> hello = new Cons<String>("Hello, ", mstr);
|
||||
ILo<String> world = new Cons<String>("world.", mstr);
|
||||
ILo<String> ajcmsdj = new Cons<String>("ajcmsdj", mstr);
|
||||
ILo<String> helloWorld = new Cons<String>("Hello, ", new Cons<String>("world.", mstr));
|
||||
ILo<String> helloAjcmsdj = new Cons<String>("Hello, ", ajcmsdj);
|
||||
ILo<String> h = new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhhh", mstr)));
|
||||
|
||||
boolean testILoAppend(Tester t) {
|
||||
return t.checkExpect(hello.append(world), helloWorld) &&
|
||||
t.checkExpect(lint.append(mint), lint) &&
|
||||
t.checkExpect(mint.append(lint), lint);
|
||||
}
|
||||
|
||||
boolean testILoArmax(Tester t) {
|
||||
return t.checkExpect(helloWorld.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(helloAjcmsdj.argmax(new StrLen()), "Hello, ")
|
||||
&& t.checkExpect(lint2.argmax(new IntSize()), 1)
|
||||
&& t.checkExpect(lint.argmax(new IntSize()), 92);
|
||||
}
|
||||
|
||||
boolean testILoInsertSorted(Tester t) {
|
||||
return t.checkExpect(mstr.insertSorted(new CompStrLen(), "h"), new Cons<String>("h", mstr))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "s"), new Cons<String>("s", hello))
|
||||
&& t.checkExpect(h.insertSorted(new CompStrLen(), "hhh"), new Cons<String>("h", new Cons<String>("hh", new Cons<String>("hhh", new Cons<String>("hhhh", mstr)))))
|
||||
&& t.checkExpect(hello.insertSorted(new CompStrLen(), "hello"), new Cons<String>("hello", hello));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Generic function.
|
||||
interface IFunc<X, Y> {
|
||||
Y apply(X input);
|
||||
}
|
||||
|
||||
// Extracts the value of an input.
|
||||
interface IEvaluator<X> extends IFunc<X, Integer> {}
|
||||
|
||||
// Calculate the length of a string.
|
||||
class StrLen implements IEvaluator<String> { public Integer apply(String input) {
|
||||
return input.length();
|
||||
}}
|
||||
|
||||
// Calculate the size of an integer.
|
||||
class IntSize implements IEvaluator<Integer> { public Integer apply(Integer input) {
|
||||
return input;
|
||||
}}
|
||||
|
||||
// Compares two values.
|
||||
interface IComparator<A> {
|
||||
// Returns a negative number if a1 is "smaller" than a2,
|
||||
// 0 if they are considered equal,
|
||||
// and a positive number of a1 is "bigger" than a2.
|
||||
int compare(A a1, A a2);
|
||||
}
|
||||
|
||||
// Compare string lengths.
|
||||
class CompStrLen implements IComparator<String> { public int compare(String s1, String s2) {
|
||||
return s1.length() - s2.length();
|
||||
}}
|
||||
|
||||
// A list of A.
|
||||
interface ILo<A> {
|
||||
// Append a list.
|
||||
ILo<A> append(ILo<A> a);
|
||||
// Find the largest from the evaluator.
|
||||
A argmax(IEvaluator<A> eval);
|
||||
A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal);
|
||||
// Skip this element of the list.
|
||||
ILo<A> skip();
|
||||
// Sort the list with the comparator.
|
||||
ILo<A> sort(IComparator<A> comp);
|
||||
ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted);
|
||||
// Add an element to the correct place in a sorted list.
|
||||
ILo<A> insertSorted(IComparator<A> comp, A a);
|
||||
}
|
||||
|
||||
class Cons<A> implements ILo<A> {
|
||||
A first;
|
||||
ILo<A> rest;
|
||||
|
||||
Cons(A first, ILo<A> rest) {
|
||||
this.first = first;
|
||||
this.rest = rest;
|
||||
}
|
||||
|
||||
public ILo<A> append(ILo<A> a) { return new Cons<A>(this.first, this.rest.append(a)); }
|
||||
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
return argmaxHelper(eval, this.first, eval.apply(this.first));
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
A now = this.first;
|
||||
Integer nowVal = eval.apply(now);
|
||||
|
||||
return prevVal >= nowVal ?
|
||||
this.rest.argmaxHelper(eval, prev, prevVal) :
|
||||
this.rest.skip().argmaxHelper(eval, now, nowVal);
|
||||
};
|
||||
|
||||
public ILo<A> skip() {
|
||||
return this.rest;
|
||||
}
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
if (comp.compare(a, this.first) <= 0) {
|
||||
return new Cons<A>(a, this);
|
||||
} else {
|
||||
return new Cons<A>(this.first, this.rest.insertSorted(comp, a));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class Mt<A> implements ILo<A> {
|
||||
public ILo<A> append(ILo<A> a) { return a; }
|
||||
public A argmax(IEvaluator<A> eval) {
|
||||
throw new UnsupportedOperationException("No max of empty list.");
|
||||
}
|
||||
|
||||
public A argmaxHelper(IEvaluator<A> eval, A prev, Integer prevVal) {
|
||||
return prev;
|
||||
}
|
||||
|
||||
public ILo<A> skip() { return this; }
|
||||
|
||||
public ILo<A> sort(IComparator<A> comp) { return this; }
|
||||
public ILo<A> sortHelper(IComparator<A> comp, ILo<A> sorted) {
|
||||
return sorted;
|
||||
}
|
||||
public ILo<A> insertSorted(IComparator<A> comp, A a) {
|
||||
return new Cons<A>(a, this);
|
||||
}
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,3 +1,3 @@
|
||||
#GitProjectData
|
||||
#Wed Nov 13 09:09:56 EST 2024
|
||||
#Thu Nov 21 00:04:34 EST 2024
|
||||
.gitdir=../.git
|
||||
|
||||
Binary file not shown.
@@ -1,3 +1,3 @@
|
||||
#GitProjectData
|
||||
#Tue Nov 05 15:25:59 EST 2024
|
||||
#Thu Nov 21 00:04:34 EST 2024
|
||||
.gitdir=../.git
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,3 +1,3 @@
|
||||
#GitProjectData
|
||||
#Mon Nov 18 11:29:02 EST 2024
|
||||
#Thu Nov 21 00:04:34 EST 2024
|
||||
.gitdir=../.git
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,3 +1,3 @@
|
||||
#GitProjectData
|
||||
#Tue Nov 12 12:12:54 EST 2024
|
||||
#Thu Nov 21 00:04:34 EST 2024
|
||||
.gitdir=../.git
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user