13 files changed, 352 insertions, 170 deletions

diff --git a/base/src/main/java/bjc/utils/funcutils/IBuilder.java b/base/src/main/java/bjc/utils/funcutils/Builder.java
index b1a2020..72c045d 100644
--- a/base/src/main/java/bjc/utils/funcutils/IBuilder.java
+++ b/base/src/main/java/bjc/utils/funcutils/Builder.java
@@ -8,7 +8,7 @@ package bjc.utils.funcutils;
  * @param <E>
  *            The type of object being built.
  */
-public interface IBuilder<E> {
+public interface Builder<E> {
 	/**
 	 * Build the object this builder is building.
 	 *
diff --git a/base/src/main/java/bjc/utils/funcutils/Callables.java b/base/src/main/java/bjc/utils/funcutils/Callables.java
new file mode 100644
index 0000000..5895347
--- /dev/null
+++ b/base/src/main/java/bjc/utils/funcutils/Callables.java
@@ -0,0 +1,60 @@
+package bjc.utils.funcutils;
+
+import java.util.concurrent.*;
+import java.util.function.*;
+
+/**
+ * Utility function for dealing with callables and other things.
+ * 
+ * @author Ben Culkin
+ *
+ */
+public class Callables
+{
+	/**
+	 * Perform a 'bind' that appends a function to a callable.
+	 * 
+	 * @param <Input> The type originally returned by the callable.
+	 * @param <Output> The type returned by the function.
+	 * 
+	 * @param call The original callable.
+	 * @param func The function to use to transform the result.
+	 * 
+	 * @return A callable which applies the given function to the result of them.
+	 */
+	public static <Input, Output> Callable<Output> bind(
+			Callable<Input> call, Function<Input, Callable<Output>> func)
+	{
+		return () -> func.apply(call.call()).call();
+	}
+	
+	/**
+	 * Convert a normal function to a function on callables.
+	 * 
+	 * @param <Input> The input to the function.
+	 * @param <Output> The output from the function.
+	 * 
+	 * @param func The function to convert.
+	 * 
+	 * @return The function, made to work over callables.
+	 */
+	public static <Input, Output> Function<Callable<Input>, Callable<Output>>
+	fmap(Function<Input, Output> func)
+	{
+		return (inp) -> () -> func.apply(inp.call());
+	}
+	
+	/**
+	 * Convert a future into a callable.
+	 * 
+	 * @param <Output> The type returned by the future.
+	 * 
+	 * @param fut The future to convert.
+	 * 
+	 * @return A future which yields that value.
+	 */
+	public static <Output> Callable<Output> obtain(Future<Output> fut)
+	{
+		return () -> fut.get();
+	}
+}
diff --git a/base/src/main/java/bjc/utils/funcutils/ChainIterator.java b/base/src/main/java/bjc/utils/funcutils/ChainIterator.java
new file mode 100644
index 0000000..36f94e5
--- /dev/null
+++ b/base/src/main/java/bjc/utils/funcutils/ChainIterator.java
@@ -0,0 +1,54 @@
+package bjc.utils.funcutils;
+
+import java.util.*;
+import java.util.function.*;
+
+/**
+ * A chain iterator. This is essentially flatMap in iterator form.
+ * 
+ * @author bjculkin
+ *
+ * @param <T1>
+ *             The type of the input values.
+ *
+ * @param <T2>
+ *             The type of the output values.
+ */
+public class ChainIterator<T1, T2> implements Iterator<T2> {
+	private Iterator<T1> mainItr;
+	private Function<T1, Iterator<T2>> trans;
+
+	private Iterator<T2> curItr;
+
+	/**
+	 * Create a new chain iterator.
+	 *
+	 * @param mainItr
+	 *                The main iterator for input.
+	 *
+	 * @param trans
+	 *                The transformation to use to produce the outputs.
+	 */
+	public ChainIterator(Iterator<T1> mainItr, Function<T1, Iterator<T2>> trans) {
+		this.mainItr = mainItr;
+		this.trans = trans;
+	}
+
+	@Override
+	public boolean hasNext() {
+		if (curItr != null) {
+			return curItr.hasNext() ? true : mainItr.hasNext();
+		}
+
+		return mainItr.hasNext();
+	}
+
+	@Override
+	public T2 next() {
+		if (curItr == null || !curItr.hasNext()) {
+			curItr = trans.apply(mainItr.next());
+		}
+
+		return curItr.next();
+	}
+}
\ No newline at end of file
diff --git a/base/src/main/java/bjc/utils/funcutils/CollectorUtils.java b/base/src/main/java/bjc/utils/funcutils/CollectorUtils.java
index 81313c8..a92c2d1 100644
--- a/base/src/main/java/bjc/utils/funcutils/CollectorUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/CollectorUtils.java
@@ -2,8 +2,8 @@ package bjc.utils.funcutils;
 
 import java.util.stream.Collector;
 
-import bjc.data.IHolder;
-import bjc.data.IPair;
+import bjc.data.Holder;
+import bjc.data.Pair;
 
 /**
  * Utilities for producing implementations of {@link Collector}
@@ -38,8 +38,8 @@ public class CollectorUtils {
 	 * @return A collector that functions as mentioned above.
 	 */
 	public static <InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
-			Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>,
-					IPair<FinalType1, FinalType2>>
+			Collector<InitialType, Holder<Pair<AuxType1, AuxType2>>,
+					Pair<FinalType1, FinalType2>>
 			compoundCollect(final Collector<InitialType, AuxType1, FinalType1> first,
 					final Collector<InitialType, AuxType2, FinalType2> second) {
 		return new CompoundCollector<>(first, second);
diff --git a/base/src/main/java/bjc/utils/funcutils/CompoundCollector.java b/base/src/main/java/bjc/utils/funcutils/CompoundCollector.java
index 5e51c20..5aa266e 100644
--- a/base/src/main/java/bjc/utils/funcutils/CompoundCollector.java
+++ b/base/src/main/java/bjc/utils/funcutils/CompoundCollector.java
@@ -7,10 +7,10 @@ import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collector;
 
-import bjc.data.IHolder;
-import bjc.data.IPair;
-import bjc.data.Identity;
+import bjc.data.Holder;
 import bjc.data.Pair;
+import bjc.data.Identity;
+import bjc.data.SimplePair;
 
 /**
  * Implementation of a collecter that uses two collectors.
@@ -18,8 +18,8 @@ import bjc.data.Pair;
  * @author Ben Culkin
  */
 final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, FinalType2>
-		implements Collector<InitialType, IHolder<IPair<AuxType1, AuxType2>>,
-				IPair<FinalType1, FinalType2>> {
+		implements Collector<InitialType, Holder<Pair<AuxType1, AuxType2>>,
+				Pair<FinalType1, FinalType2>> {
 	/* Our characteristics. */
 	private final Set<java.util.stream.Collector.Characteristics> characteristicSet;
 
@@ -48,7 +48,7 @@ final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, Final
 	}
 
 	@Override
-	public BiConsumer<IHolder<IPair<AuxType1, AuxType2>>, InitialType> accumulator() {
+	public BiConsumer<Holder<Pair<AuxType1, AuxType2>>, InitialType> accumulator() {
 		final BiConsumer<AuxType1, InitialType> firstAccumulator = first.accumulator();
 		final BiConsumer<AuxType2, InitialType> secondAccumulator = second.accumulator();
 
@@ -68,7 +68,7 @@ final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, Final
 	}
 
 	@Override
-	public BinaryOperator<IHolder<IPair<AuxType1, AuxType2>>> combiner() {
+	public BinaryOperator<Holder<Pair<AuxType1, AuxType2>>> combiner() {
 		final BinaryOperator<AuxType1> firstCombiner = first.combiner();
 		final BinaryOperator<AuxType2> secondCombiner = second.combiner();
 
@@ -80,25 +80,25 @@ final class CompoundCollector<InitialType, AuxType1, AuxType2, FinalType1, Final
 	}
 
 	@Override
-	public Function<IHolder<IPair<AuxType1, AuxType2>>, IPair<FinalType1, FinalType2>>
+	public Function<Holder<Pair<AuxType1, AuxType2>>, Pair<FinalType1, FinalType2>>
 			finisher() {
 		return state -> state.unwrap(pair -> {
 			return pair.bind((left, right) -> {
 				final FinalType1 finalLeft = first.finisher().apply(left);
 				final FinalType2 finalRight = second.finisher().apply(right);
 
-				return new Pair<>(finalLeft, finalRight);
+				return new SimplePair<>(finalLeft, finalRight);
 			});
 		});
 	}
 
 	@Override
-	public Supplier<IHolder<IPair<AuxType1, AuxType2>>> supplier() {
+	public Supplier<Holder<Pair<AuxType1, AuxType2>>> supplier() {
 		return () -> {
 			final AuxType1 initialLeft = first.supplier().get();
 			final AuxType2 initialRight = second.supplier().get();
 
-			return new Identity<>(new Pair<>(initialLeft, initialRight));
+			return new Identity<>(new SimplePair<>(initialLeft, initialRight));
 		};
 	}
 }
diff --git a/base/src/main/java/bjc/utils/funcutils/EnumUtils.java b/base/src/main/java/bjc/utils/funcutils/EnumUtils.java
index e8898ca..6d53952 100644
--- a/base/src/main/java/bjc/utils/funcutils/EnumUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/EnumUtils.java
@@ -4,7 +4,7 @@ import java.util.Random;
 import java.util.function.Consumer;
 
 import bjc.funcdata.FunctionalList;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 
 /**
  * Utility methods on enums.
@@ -34,7 +34,7 @@ public class EnumUtils {
 			final int nValues, final Consumer<E> action, final Random rnd) {
 		final E[] enumValues = clasz.getEnumConstants();
 
-		final IList<E> valueList = new FunctionalList<>(enumValues);
+		final ListEx<E> valueList = new FunctionalList<>(enumValues);
 
 		final int randomValueCount = enumValues.length - nValues;
 
diff --git a/base/src/main/java/bjc/utils/funcutils/FuncUtils.java b/base/src/main/java/bjc/utils/funcutils/FuncUtils.java
index 70e521a..2c65876 100644
--- a/base/src/main/java/bjc/utils/funcutils/FuncUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/FuncUtils.java
@@ -29,9 +29,12 @@ public class FuncUtils {
 	 *
 	 * @return The function transformed into a unary function returning a function.
 	 */
-	public static <A, B, C> Function<A, Function<B, C>>
-			curry2(final BiFunction<A, B, C> func) {
-		return arg1 -> arg2 -> func.apply(arg1, arg2);
+	public static <A, B, C> Function<A, Function<B, C>> curry2(
+			final BiFunction<A, B, C> func)
+	{
+		return arg1 ->
+			arg2 ->
+				func.apply(arg1, arg2);
 	}
 
 	/**
@@ -43,14 +46,17 @@ public class FuncUtils {
 	 * @param cons
 	 *               The action to perform.
 	 */
-	public static void doTimes(final int nTimes, final Consumer<Integer> cons) {
-		for (int i = 0; i < nTimes; i++) {
-			cons.accept(i);
-		}
+	public static void doTimes(
+			final int nTimes,
+			final Consumer<Integer> cons) 
+	{
+		for (int i = 0; i < nTimes; i++) cons.accept(i);
 	}
 
 	/**
 	 * Return an operator that executes until it converges.
+	 * 
+	 * @param <T> The type the operator is on.
 	 *
 	 * @param op
 	 *                 The operator to execute.
@@ -62,12 +68,15 @@ public class FuncUtils {
 	 * @return The requested operator.
 	 */
 	public static <T> UnaryOperator<T> converge(final UnaryOperator<T> op,
-			final int maxTries) {
+			final int maxTries) 
+	{
 		return converge(op, Object::equals, maxTries);
 	}
 
 	/**
 	 * Return an operator that executes until it converges.
+	 * 
+	 * @param <T> The type the operator is on.
 	 *
 	 * @param op
 	 *                  The operator to execute.
@@ -81,11 +90,14 @@ public class FuncUtils {
 	 *
 	 * @return The requested operator.
 	 */
-	public static <T> UnaryOperator<T> converge(final UnaryOperator<T> op,
-			final BiPredicate<T, T> converged, final int maxTries) {
+	public static <T> UnaryOperator<T> converge(
+			final UnaryOperator<T> op,
+			final BiPredicate<T, T> converged,
+			final int maxTries) 
+	{
 		return val -> {
 			T newVal = op.apply(val);
-			T oldVal;
+			T oldVal = newVal;
 
 			int tries = 0;
 
diff --git a/base/src/main/java/bjc/utils/funcutils/Isomorphism.java b/base/src/main/java/bjc/utils/funcutils/Isomorphism.java
deleted file mode 100644
index c219d7f..0000000
--- a/base/src/main/java/bjc/utils/funcutils/Isomorphism.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package bjc.utils.funcutils;
-
-import java.util.function.Function;
-
-/**
- * A pair of functions to transform between a pair of types.
- *
- * @author bjculkin
- *
- * @param <S>
- *            The source type of the isomorphism.
- *
- * @param <D>
- *            The destination type of isomorphism.
- */
-public class Isomorphism<S, D> {
-	/* The function to the destination type. */
-	private Function<S, D> toFunc;
-	/* The function to the source type. */
-	private Function<D, S> fromFunc;
-
-	/**
-	 * Create a new isomorphism.
-	 *
-	 * @param to
-	 *             The 'forward' function, from the source to the definition.
-	 *
-	 * @param from
-	 *             The 'backward' function, from the definition to the source.
-	 */
-	public Isomorphism(Function<S, D> to, Function<D, S> from) {
-		toFunc = to;
-		fromFunc = from;
-	}
-
-	/**
-	 * Apply the isomorphism forward.
-	 *
-	 * @param val
-	 *            The source value.
-	 *
-	 * @return The destination value.
-	 */
-	public D to(S val) {
-		return toFunc.apply(val);
-	}
-
-	/**
-	 * Apply the isomorphism backward.
-	 *
-	 * @param val
-	 *            The destination value.
-	 *
-	 * @return The source value.
-	 */
-	public S from(D val) {
-		return fromFunc.apply(val);
-	}
-}
diff --git a/base/src/main/java/bjc/utils/funcutils/IteratorUtils.java b/base/src/main/java/bjc/utils/funcutils/IteratorUtils.java
index 8d51996..662b1bf 100644
--- a/base/src/main/java/bjc/utils/funcutils/IteratorUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/IteratorUtils.java
@@ -3,7 +3,7 @@ package bjc.utils.funcutils;
 import java.util.*;
 import java.util.function.*;
 
-import bjc.data.ArrayIterator;
+import bjc.data.*;
 
 /**
  * Utility methods for dealing with iterators.
@@ -13,57 +13,9 @@ import bjc.data.ArrayIterator;
  */
 public class IteratorUtils {
 	/**
-	 * A chain iterator. This is essentially flatMap in iterator form.
-	 * 
-	 * @author bjculkin
-	 *
-	 * @param <T1>
-	 *             The type of the input values.
-	 *
-	 * @param <T2>
-	 *             The type of the output values.
-	 */
-	public static class ChainIterator<T1, T2> implements Iterator<T2> {
-		private Iterator<T1> mainItr;
-		private Function<T1, Iterator<T2>> trans;
-
-		private Iterator<T2> curItr;
-
-		/**
-		 * Create a new chain iterator.
-		 *
-		 * @param mainItr
-		 *                The main iterator for input.
-		 *
-		 * @param trans
-		 *                The transformation to use to produce the outputs.
-		 */
-		public ChainIterator(Iterator<T1> mainItr, Function<T1, Iterator<T2>> trans) {
-			this.mainItr = mainItr;
-			this.trans = trans;
-		}
-
-		@Override
-		public boolean hasNext() {
-			if (curItr != null) {
-				return curItr.hasNext() ? true : mainItr.hasNext();
-			}
-
-			return mainItr.hasNext();
-		}
-
-		@Override
-		public T2 next() {
-			if (curItr == null || !curItr.hasNext()) {
-				curItr = trans.apply(mainItr.next());
-			}
-
-			return curItr.next();
-		}
-	}
-
-	/**
 	 * Convert an iterator to an iterable.
+	 * 
+	 * @param <E> The type being iterated over.
 	 *
 	 * @param itr
 	 *            The iterator to convert.
@@ -77,6 +29,8 @@ public class IteratorUtils {
 	/**
 	 * Convert an iterable to an iterator.
 	 *
+	 * @param <E> The type being iterated over.
+	 * 
 	 * @param itr
 	 *            The iterable to convert.
 	 *
@@ -89,18 +43,23 @@ public class IteratorUtils {
 	/**
 	 * Convert an array to an iterator.
 	 *
+	 * @param <E> The type being iterated over.
+	 * 
 	 * @param parms
 	 *              The array to iterate over.
 	 *
 	 * @return An iterator over the provided array.
 	 */
 	@SafeVarargs
-	public static <E> Iterator<E> AI(E... parms) {
+	public static <E> Iterator<E> I(E... parms) {
 		return new ArrayIterator<>(parms);
 	}
 
 	/**
 	 * Create a chain iterator.
+	 * 
+	 * @param <A> The initial type being iterated over.
+	 * @param <B> The resulting type being iterated over.
 	 *
 	 * @param itrA
 	 *             The iterator for input values.
@@ -114,4 +73,43 @@ public class IteratorUtils {
 			Function<A, Iterator<B>> itrB) {
 		return new ChainIterator<>(itrA, itrB);
 	}
+	
+	/**
+	 * Perform a left-fold over an iterator.
+	 * 
+	 * @param <ElementType> The type of elements in the iterator.
+	 * @param <ResultType> The result from the fold.
+	 * 
+	 * @param itr The items to iterate over.
+	 * @param zero The initial element for the fold.
+	 * @param folder The function that does the folding.
+	 * 
+	 * @return The result of folding over the iterator.
+	 */
+	public static <ElementType, ResultType> ResultType foldLeft(
+			Iterable<ElementType> itr,
+			ResultType zero,
+			BiFunction<ElementType, ResultType, ResultType> folder)
+	{
+		ResultType state = zero;
+		for (ElementType elem : itr) {
+			state = folder.apply(elem, state);
+		}
+		return state;
+	}
+	
+	/**
+	 * Creates an 'entangled' pair of a consumer and an iterator.
+	 * 
+	 * @param <ElementType> The type of value involved.
+	 * 
+	 * @return A pair consisting of a consumer of values, and an iterator that
+	 *         yields the consumed values.
+	 */
+	public static <ElementType>
+	Pair<Consumer<ElementType>, Iterator<ElementType>> entangle()
+	{
+		Queue<ElementType> backer = new ArrayDeque<>();
+		return Pair.pair(backer::add, new QueueBackedIterator<>(backer));
+	}
 }
diff --git a/base/src/main/java/bjc/utils/funcutils/ListUtils.java b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
index e3662af..17642ce 100644
--- a/base/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -7,7 +7,7 @@ import java.util.List;
 import java.util.function.*;
 
 import bjc.funcdata.FunctionalList;
-import bjc.funcdata.IList;
+import bjc.funcdata.ListEx;
 
 /**
  * Utilities for manipulating FunctionalLists and regular Collections lists that
@@ -27,7 +27,7 @@ public class ListUtils {
 	 *
 	 * @return The collapsed string of tokens.
 	 */
-	public static String collapseTokens(final IList<String> input) {
+	public static String collapseTokens(final ListEx<String> input) {
 		if (input == null) throw new NullPointerException("Input must not be null");
 
 		return collapseTokens(input, "");
@@ -45,7 +45,7 @@ public class ListUtils {
 	 *
 	 * @return The collapsed string of tokens.
 	 */
-	public static String collapseTokens(final IList<String> input,
+	public static String collapseTokens(final ListEx<String> input,
 			final String seperator) {
 		if (input == null)          throw new NullPointerException("Input must not be null");
 		else if (seperator == null) throw new NullPointerException("Seperator must not be null");
@@ -89,9 +89,9 @@ public class ListUtils {
 	 * @return A new list containing the desired number of items randomly selected
 	 *         from the specified list without replacement.
 	 */
-	public static <E> IList<E> drawWithoutReplacement(final IList<E> list,
+	public static <E> ListEx<E> drawWithoutReplacement(final ListEx<E> list,
 			final int number, final Function<Integer, Integer> rng) {
-		final IList<E> selected = new FunctionalList<>(new ArrayList<>(number));
+		final ListEx<E> selected = new FunctionalList<>(new ArrayList<>(number));
 
 		final int total = list.getSize();
 
@@ -133,9 +133,9 @@ public class ListUtils {
 	 * @return A new list containing the desired number of items randomly selected
 	 *         from the specified list.
 	 */
-	public static <E> IList<E> drawWithReplacement(final IList<E> list, final int number,
+	public static <E> ListEx<E> drawWithReplacement(final ListEx<E> list, final int number,
 			final Function<Integer, Integer> rng) {
-		final IList<E> selected = new FunctionalList<>(new ArrayList<>(number));
+		final ListEx<E> selected = new FunctionalList<>(new ArrayList<>(number));
 
 		for (int i = 0; i < number; i++) selected.add(list.randItem(rng));
 
@@ -161,7 +161,7 @@ public class ListUtils {
 	 *
 	 * @return A list partitioned according to the above rules.
 	 */
-	public static <E> IList<IList<E>> groupPartition(final IList<E> input,
+	public static <E> ListEx<ListEx<E>> groupPartition(final ListEx<E> input,
 			final Function<E, Integer> counter, final int partitionSize) {
 		if (input == null) {
 			throw new NullPointerException("Input list must not be null");
@@ -176,10 +176,10 @@ public class ListUtils {
 		}
 
 		/* List that holds our results. */
-		final IList<IList<E>> returned = new FunctionalList<>();
+		final ListEx<ListEx<E>> returned = new FunctionalList<>();
 
 		/* List that holds elements rejected during current pass. */
-		final IList<E> rejected = new FunctionalList<>();
+		final ListEx<E> rejected = new FunctionalList<>();
 
 		final GroupPartIteration<E> it
 				= new GroupPartIteration<>(returned, rejected, partitionSize, counter);
@@ -215,10 +215,10 @@ public class ListUtils {
 	 * @return A list containing all the elements of the lists.
 	 */
 	@SafeVarargs
-	public static <E> IList<E> mergeLists(final IList<E>... lists) {
-		final IList<E> returned = new FunctionalList<>();
+	public static <E> ListEx<E> mergeLists(final ListEx<E>... lists) {
+		final ListEx<E> returned = new FunctionalList<>();
 
-		for (final IList<E> list : lists) {
+		for (final ListEx<E> list : lists) {
 			for (final E itm : list.toIterable()) returned.add(itm);
 		}
 
@@ -249,12 +249,12 @@ public class ListUtils {
 	 *                                  If the list couldn't be padded to the
 	 *                                  desired size.
 	 */
-	public static <E> IList<E> padList(final IList<E> list,
+	public static <E> ListEx<E> padList(final ListEx<E> list,
 			final Function<E, Integer> counter, final int size,
 			final Supplier<E> padder) {
 		int count = 0;
 
-		final IList<E> returned = new FunctionalList<>();
+		final ListEx<E> returned = new FunctionalList<>();
 
 		for (final E itm : list.toIterable()) {
 			count += counter.apply(itm);
@@ -433,12 +433,12 @@ public class ListUtils {
  */
 class GroupPartIteration<E> implements Consumer<E> {
 	/* The list we're returning. */
-	private final IList<IList<E>> returnedList;
+	private final ListEx<ListEx<E>> returnedList;
 
 	/* The current partition of the list. */
-	public IList<E> currentPartition;
+	public ListEx<E> currentPartition;
 	/* The items rejected from the current partition. */
-	private final IList<E> rejectedItems;
+	private final ListEx<E> rejectedItems;
 
 	/* The number of items in the current partition. */
 	private int numberInCurrentPartition;
@@ -465,7 +465,7 @@ class GroupPartIteration<E> implements Consumer<E> {
 	 * @param eleCount
 	 *                 The function to use to determine the value of an item.
 	 */
-	public GroupPartIteration(final IList<IList<E>> returned, final IList<E> rejects,
+	public GroupPartIteration(final ListEx<ListEx<E>> returned, final ListEx<E> rejects,
 			final int nPerPart, final Function<E, Integer> eleCount) {
 		this.returnedList = returned;
 		this.rejectedItems = rejects;
diff --git a/base/src/main/java/bjc/utils/funcutils/QueueBackedIterator.java b/base/src/main/java/bjc/utils/funcutils/QueueBackedIterator.java
new file mode 100644
index 0000000..8b9f401
--- /dev/null
+++ b/base/src/main/java/bjc/utils/funcutils/QueueBackedIterator.java
@@ -0,0 +1,36 @@
+package bjc.utils.funcutils;
+
+import java.util.*;
+
+/**
+ * An iterator backed by a queue.
+ * 
+ * @author Ben Culkin
+ *
+ * @param <ElementType> The type of element
+ */
+public class QueueBackedIterator<ElementType>
+		implements Iterator<ElementType>
+{
+	private final Queue<ElementType> backer;
+
+	/**
+	 * Create a new queue-backed iterator.
+	 * 
+	 * @param backer The queue which backs this iterator.
+	 */
+	public QueueBackedIterator(Queue<ElementType> backer)
+	{
+		this.backer = backer;
+	}
+
+	@Override
+	public boolean hasNext() {
+		return !backer.isEmpty();
+	}
+
+	@Override
+	public ElementType next() {
+		return backer.remove();
+	}
+}
\ No newline at end of file
diff --git a/base/src/main/java/bjc/utils/funcutils/Strategy.java b/base/src/main/java/bjc/utils/funcutils/Strategy.java
new file mode 100644
index 0000000..316879f
--- /dev/null
+++ b/base/src/main/java/bjc/utils/funcutils/Strategy.java
@@ -0,0 +1,81 @@
+package bjc.utils.funcutils;
+
+import java.util.concurrent.*;
+import java.util.function.*;
+
+/**
+ * Strategy for dealing with parallel execution.
+ * 
+ * @author Ben Culkin
+ * 
+ * @param <Output> The type returned by the tasks.
+ *
+ */
+public interface Strategy<Output> extends Function<Callable<Output>, Future<Output>>
+{
+	/**
+	 * Convert a function into one which operates concurrently, using this strategy.
+	 * 
+	 * @param <Input> The type of the function argument.
+	 * 
+	 * @param func The type of the function.
+	 * 
+	 * @return A function which executes concurrently.
+	 */
+	public default <Input> Function<Input, Future<Output>> using(Function<Input, Output> func)
+	{
+		return (input) -> this.apply(() -> func.apply(input));
+	}
+	
+	/**
+	 * A strategy which will run tasks in serial.
+	 * 
+	 * @param <Output> The type returned by the task.
+	 * 
+	 * @return A strategy which executes things serially.
+	 */
+	public static <Output> Strategy<Output> serial()
+	{
+		return (call) -> {
+			FutureTask<Output> task = new FutureTask<>(call);
+			task.run();
+			return task;
+		};
+	}
+	/**
+	 * A strategy which creates a fresh thread to execute a task on.
+	 * 
+	 * @param <Output> The type returned by the task.
+	 * 
+	 * @return A strategy which uses threads to create tasks.
+	 */
+	public static <Output> Strategy<Output> simpleThread()
+	{
+		// I leave this as an example as of what is possible with combinators.
+		// return (call) -> invoke(introducing(
+		// 		() -> new FutureTask<>(call),
+		// 		(task, input) -> doWith(
+		// 				(FutureTask<Output> tsk) ->
+		// 					new Thread(task).start()).apply(task)
+		// ));
+		return (call) -> {
+			FutureTask<Output> task = new FutureTask<>(call);
+			new Thread(task).start();
+			return task;
+		};
+	}
+	
+	/**
+	 * A strategy that uses an executor service.
+	 * 
+	 * @param <Output> The type returned by the task.
+	 * 
+	 * @param svc The executor service to use.
+	 * 
+	 * @return A strategy which uses the provided executor.
+	 */
+	public static <Output> Strategy<Output> executorService(ExecutorService svc)
+	{
+		return svc::submit;
+	}
+}
diff --git a/base/src/main/java/bjc/utils/funcutils/TreeUtils.java b/base/src/main/java/bjc/utils/funcutils/TreeUtils.java
index 59f60a2..41a01d8 100644
--- a/base/src/main/java/bjc/utils/funcutils/TreeUtils.java
+++ b/base/src/main/java/bjc/utils/funcutils/TreeUtils.java
@@ -21,8 +21,8 @@ public class TreeUtils {
 	 *                   The path to mark nodes with.
 	 * @return The list of marked paths.
 	 */
-	public static <T> IList<IList<T>> outlineTree(ITree<T> tre, Predicate<T> leafMarker) {
-		IList<IList<T>> paths = new FunctionalList<>();
+	public static <T> ListEx<ListEx<T>> outlineTree(Tree<T> tre, Predicate<T> leafMarker) {
+		ListEx<ListEx<T>> paths = new FunctionalList<>();
 
 		LinkedList<T> path = new LinkedList<>();
 		path.add(tre.getHead());
@@ -33,11 +33,11 @@ public class TreeUtils {
 	}
 
 	/* Find a path in a tree. */
-	private static <T> void findPath(ITree<T> subtree, LinkedList<T> path,
-			Predicate<T> leafMarker, IList<IList<T>> paths) {
+	private static <T> void findPath(Tree<T> subtree, LinkedList<T> path,
+			Predicate<T> leafMarker, ListEx<ListEx<T>> paths) {
 		if (subtree.getChildrenCount() == 0 && leafMarker.test(subtree.getHead())) {
 			/* We're at a matching leaf node. Add it. */
-			IList<T> finalPath = new FunctionalList<>();
+			ListEx<T> finalPath = new FunctionalList<>();
 
 			for (T ePath : path) finalPath.add(ePath);
 
@@ -63,10 +63,10 @@ public class TreeUtils {
 	 * @param expander The function to expand nodes.
 	 * @return A transformed copy of the tree.
 	 */
-	public static <ContainedType> ITree<ContainedType> substitute(
-			ITree<ContainedType> tree,
+	public static <ContainedType> Tree<ContainedType> substitute(
+			Tree<ContainedType> tree,
 			Predicate<ContainedType> marker,
-			Function<ContainedType, ITree<ContainedType>> expander) {
+			Function<ContainedType, Tree<ContainedType>> expander) {
 		tree.topDownTransform((contents) -> {
 			if (marker.test(contents)) return TopDownTransformResult.TRANSFORM;
 			else                       return TopDownTransformResult.PASSTHROUGH;
@@ -84,9 +84,9 @@ public class TreeUtils {
 	 * @param environment A map which contains the variables to substitute.
 	 * @return A transformed copy of the tree.
 	 */
-	public static <ContainedType> ITree<ContainedType> substitute(
-			ITree<ContainedType> tree,
-			IMap<ContainedType, ITree<ContainedType>> environment) {
+	public static <ContainedType> Tree<ContainedType> substitute(
+			Tree<ContainedType> tree,
+			MapEx<ContainedType, Tree<ContainedType>> environment) {
 		return substitute(
 				tree,
 				environment::containsKey,