Switch functional data to use interfaces

30 files changed, 1153 insertions, 483 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/cli/GeneralCommandMode.java b/BJC-Utils2/src/main/java/bjc/utils/cli/GeneralCommandMode.java
index 4a41c1c..880e8c5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/cli/GeneralCommandMode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/cli/GeneralCommandMode.java
@@ -1,10 +1,11 @@
 package bjc.utils.cli;
 
-import java.util.HashMap;
-import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalMap;
+
 /**
  * A general command mode, with a customizable set of commands
  * 
@@ -16,17 +17,19 @@ import java.util.function.Consumer;
  *
  */
 public class GeneralCommandMode implements ICommandMode {
-	private Map<String, ICommandHandler>	commandHandlers;
-	private String							customPrompt;
+	private IFunctionalMap<String, ICommand>		commandHandlers;
+	private IFunctionalMap<String, ICommand>		defaultHandlers;
+
+	private IFunctionalMap<String, ICommandHelp>	helpTopics;
 
-	private Map<String, ICommandHandler>	defaultHandlers;
+	private BiConsumer<String, String[]>			unknownCommandHandler;
 
-	private Consumer<String>				errorOutput;
-	private String							modeName;
+	private Consumer<String>						errorOutput;
+	private Consumer<String>						normalOutput;
 
-	private Consumer<String>				normalOutput;
+	private String									modeName;
 
-	private BiConsumer<String, String[]>	unknownCommandHandler;
+	private String									customPrompt;
 
 	/**
 	 * Create a new general command mode
@@ -41,20 +44,35 @@ public class GeneralCommandMode implements ICommandMode {
 		this.normalOutput = normalOutput;
 		this.errorOutput = errorOutput;
 
-		commandHandlers = new HashMap<>();
-		defaultHandlers = new HashMap<>();
+		commandHandlers = new FunctionalMap<>();
+		defaultHandlers = new FunctionalMap<>();
 
-		defaultHandlers.put("list", (args) -> {
+		defaultHandlers.put("list", new GenericCommand((args) -> {
 			listCommands();
 
 			return this;
-		});
+		}, "list\tList available command",
+				"Lists all of the commands available in this mode,"
+						+ " as well as the commands that are valid in any mode."));
 
-		defaultHandlers.put("alias", (args) -> {
+		defaultHandlers.put("alias", new GenericCommand((args) -> {
 			aliasCommands(args);
 
 			return this;
-		});
+		}, "alias\tAlias one command to another",
+				"alias gives a command another name it can be invoked by. It is invoked"
+						+ " with two arguments, the name of the command to alias"
+						+ ", and the alias to give that command."));
+
+		defaultHandlers.put("help", new GenericCommand((args) -> {
+			// TODO implement help system
+			return this;
+		}, "help\tConsult the help system",
+				"help consults the internal help system."
+						+ " It can be invoked in two ways. Invoking it with no arguments"
+						+ " causes it to print out all the topics you can ask for details on,"
+						+ " while invoking it with the name of a topic will print the entry"
+						+ " for that topic"));
 	}
 
 	/**
@@ -100,8 +118,7 @@ public class GeneralCommandMode implements ICommandMode {
 	 *             if the specified command already has a handler
 	 *             registered
 	 */
-	public void addCommandHandler(String command,
-			ICommandHandler handler) {
+	public void addCommandHandler(String command, ICommand handler) {
 		if (command == null) {
 			throw new NullPointerException("Command must not be null");
 		} else if (handler == null) {
@@ -162,14 +179,14 @@ public class GeneralCommandMode implements ICommandMode {
 		normalOutput.accept(
 				"The available commands for this mode are as follows:\n");
 
-		commandHandlers.keySet().forEach((commandName) -> {
+		commandHandlers.keyList().forEach((commandName) -> {
 			normalOutput.accept("\t" + commandName);
 		});
 
 		normalOutput.accept(
 				"\nThe following commands are available in all modes:\n");
 
-		defaultHandlers.keySet().forEach((commandName) -> {
+		defaultHandlers.keyList().forEach((commandName) -> {
 			normalOutput.accept("\t" + commandName);
 		});
 
@@ -181,14 +198,11 @@ public class GeneralCommandMode implements ICommandMode {
 		normalOutput.accept("\n");
 
 		if (defaultHandlers.containsKey(command)) {
-			return defaultHandlers.get(command).handle(args);
+			return defaultHandlers.get(command).getHandler().handle(args);
 		} else if (commandHandlers.containsKey(command)) {
-			return commandHandlers.get(command).handle(args);
+			return commandHandlers.get(command).getHandler().handle(args);
 		} else {
-			if (unknownCommandHandler == null) {
-				throw new UnsupportedOperationException(
-						"Command " + command + " is invalid.");
-			} else if (args != null) {
+			if (args != null) {
 				errorOutput.accept("ERROR: Unrecognized command " + command
 						+ String.join(" ", args));
 			} else {
@@ -196,6 +210,11 @@ public class GeneralCommandMode implements ICommandMode {
 						.accept("ERROR: Unrecognized command " + command);
 			}
 
+			if (unknownCommandHandler == null) {
+				throw new UnsupportedOperationException(
+						"Command " + command + " is invalid.");
+			}
+
 			unknownCommandHandler.accept(command, args);
 		}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommand.java b/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommand.java
new file mode 100644
index 0000000..99951cc
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommand.java
@@ -0,0 +1,59 @@
+package bjc.utils.cli;
+
+/**
+ * Generic command implementation
+ * 
+ * @author ben
+ *
+ */
+public class GenericCommand implements ICommand {
+	private static class GenericHelp implements ICommandHelp {
+		private String	summary;
+		private String	description;
+
+		public GenericHelp(String summary, String description) {
+			this.summary = summary;
+			this.description = description;
+		}
+
+		@Override
+		public String getSummary() {
+			return summary;
+		}
+
+		@Override
+		public String getDescription() {
+			return description;
+		}
+
+	}
+
+	private ICommandHandler	handler;
+	private ICommandHelp	help;
+
+	/**
+	 * Create a new generic command
+	 * 
+	 * @param handler
+	 *            The handler to use for the command
+	 * @param description
+	 *            The description of the command
+	 * @param help
+	 *            The detailed help message for the command
+	 */
+	public GenericCommand(ICommandHandler handler, String description,
+			String help) {
+		this.handler = handler;
+		this.help = new GenericHelp(description, help);
+	}
+
+	@Override
+	public ICommandHandler getHandler() {
+		return handler;
+	}
+
+	@Override
+	public ICommandHelp getHelp() {
+		return help;
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/cli/ICommand.java b/BJC-Utils2/src/main/java/bjc/utils/cli/ICommand.java
new file mode 100644
index 0000000..681986d
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/cli/ICommand.java
@@ -0,0 +1,23 @@
+package bjc.utils.cli;
+
+/**
+ * Represents a command that can be invoked from a {@link ICommandMode}
+ * 
+ * @author ben
+ *
+ */
+public interface ICommand {
+	/**
+	 * Get the handler that executes this command
+	 * 
+	 * @return The handler that executes this command
+	 */
+	public ICommandHandler getHandler();
+
+	/**
+	 * Get the help entry for this command
+	 * 
+	 * @return The help entry for this command
+	 */
+	public ICommandHelp getHelp();
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/cli/ICommandHelp.java b/BJC-Utils2/src/main/java/bjc/utils/cli/ICommandHelp.java
new file mode 100644
index 0000000..ad03dac
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/cli/ICommandHelp.java
@@ -0,0 +1,26 @@
+package bjc.utils.cli;
+
+/**
+ * Interface for the help entry for a command
+ * 
+ * @author ben
+ *
+ */
+public interface ICommandHelp {
+	/**
+	 * Get the summary line for a command
+	 * 
+	 * Used for 'help commands' which gives the user a brief idea what all
+	 * the commands do
+	 * 
+	 * @return The summary line line for a command
+	 */
+	public String getSummary();
+
+	/**
+	 * Get the description of a command
+	 * 
+	 * @return The description of a command
+	 */
+	public String getDescription();
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java b/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java
index 4aea0d6..37c94f6 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java
@@ -2,14 +2,15 @@ package bjc.utils.components;
 
 import java.io.File;
 import java.nio.file.Path;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.function.Function;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 
 /**
  * A component repository that loads its components from files in a
@@ -29,7 +30,7 @@ public class FileComponentRepository<E extends IDescribedComponent>
 	/**
 	 * The internal storage of components
 	 */
-	private Map<String, E>		components;
+	private IFunctionalMap<String, E>		components;
 
 	/**
 	 * The path that all the components came from
@@ -57,7 +58,8 @@ public class FileComponentRepository<E extends IDescribedComponent>
 					+ "Components can only be read from a directory");
 		}
 
-		components = new HashMap<>();
+		components = new FunctionalMap<>();
+		
 		sourceDirectory = directory.toPath().toAbsolutePath();
 
 		File[] listFiles = directory.listFiles();
@@ -100,8 +102,8 @@ public class FileComponentRepository<E extends IDescribedComponent>
 	}
 
 	@Override
-	public FunctionalList<E> getComponentList() {
-		FunctionalList<E> returnedList = new FunctionalList<>();
+	public IFunctionalList<E> getComponentList() {
+		IFunctionalList<E> returnedList = new FunctionalList<>();
 
 		components
 				.forEach((name, component) -> returnedList.add(component));
@@ -110,7 +112,7 @@ public class FileComponentRepository<E extends IDescribedComponent>
 	}
 
 	@Override
-	public Map<String, E> getComponents() {
+	public IFunctionalMap<String, E> getComponents() {
 		return components;
 	}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/components/IComponentRepository.java b/BJC-Utils2/src/main/java/bjc/utils/components/IComponentRepository.java
index 135e609..c720015 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/components/IComponentRepository.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/components/IComponentRepository.java
@@ -1,8 +1,7 @@
 package bjc.utils.components;
 
-import java.util.Map;
-
-import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 
 /**
  * A collection of implementations of {@link IDescribedComponent}
@@ -18,7 +17,7 @@ public interface IComponentRepository<E extends IDescribedComponent> {
 	 * 
 	 * @return A list of all the registered components
 	 */
-	public FunctionalList<E> getComponentList();
+	public IFunctionalList<E> getComponentList();
 
 	/**
 	 * Get all of the components this repository knows about
@@ -26,7 +25,7 @@ public interface IComponentRepository<E extends IDescribedComponent> {
 	 * @return A map from component name to component, containing all of
 	 *         the components in the repositories
 	 */
-	public Map<String, E> getComponents();
+	public IFunctionalMap<String, E> getComponents();
 
 	/**
 	 * Get a component with a specific name
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
index 97cb195..f721a9a 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
@@ -92,4 +92,9 @@ public class Pair<L, R> implements IPair<L, R> {
 
 		return merger.apply(leftValue, rightValue);
 	}
+	
+	@Override
+	public String toString() {
+		return "pair[l=" + leftValue.toString() + ", r=" + rightValue.toString() + "]";
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java
index 4b8ed30..2ad8dbf 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java
@@ -6,6 +6,7 @@ import java.util.function.Supplier;
 
 import bjc.utils.data.IHolder;
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * Holds a single value of a specific type. This is used for indirect
@@ -22,15 +23,19 @@ import bjc.utils.funcdata.FunctionalList;
 public class LazyHolder<T> implements IHolder<T>, ILazy {
 	private final class LazyHolderSupplier<NewT>
 			implements Supplier<NewT> {
-		private FunctionalList<Function<T, T>>	pendingActions;
+		private IFunctionalList<Function<T, T>>	pendingActions;
 		private Function<T, NewT>				pendingTransform;
 
-		public LazyHolderSupplier(FunctionalList<Function<T, T>> actons,
+		public LazyHolderSupplier(IFunctionalList<Function<T, T>> actons,
 				Function<T, NewT> transform) {
 			// Resolve latent bug I just realized. After a map, adding new
 			// actions to the original holder could've resulted in changes
 			// to all unactualized mapped values from that holder
-			pendingActions = actons.clone();
+			pendingActions = new FunctionalList<>();
+
+			for (Function<T, T> action : actons.toIterable()) {
+				pendingActions.add(action);
+			}
 
 			this.pendingTransform = transform;
 		}
@@ -50,7 +55,7 @@ public class LazyHolder<T> implements IHolder<T>, ILazy {
 	/**
 	 * List of queued actions to be performed on realized values
 	 */
-	private FunctionalList<Function<T, T>>	actions	= new FunctionalList<>();
+	private IFunctionalList<Function<T, T>>	actions	= new FunctionalList<>();
 
 	/**
 	 * The value internally held by this lazy holder
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
index c680879..9574376 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalList.java
@@ -14,6 +14,7 @@ import java.util.function.Predicate;
 
 import bjc.utils.data.GenHolder;
 import bjc.utils.data.IHolder;
+import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 
 import java.util.ArrayList;
@@ -28,7 +29,7 @@ import java.util.ArrayList;
  * @param <E>
  *            The type in this list
  */
-public class FunctionalList<E> implements Cloneable {
+public class FunctionalList<E> implements Cloneable, IFunctionalList<E> {
 	/**
 	 * The list used as a backing store
 	 */
@@ -57,27 +58,6 @@ public class FunctionalList<E> implements Cloneable {
 	}
 
 	/**
-	 * Create a functional list using the same backing list as the provided
-	 * list.
-	 * 
-	 * @param sourceList
-	 *            The source for a backing list
-	 */
-	public FunctionalList(FunctionalList<E> sourceList) {
-		if (sourceList == null) {
-			throw new NullPointerException("Source list must be non-null");
-		}
-
-		// Find out if this should make a copy of the source's wrapped list
-		// instead.
-		//
-		// I've decided it shouldn't. Call clone() if that's what you want.
-		// This method just creates another list that refers to the
-		// source's backing list
-		wrappedList = sourceList.wrappedList;
-	}
-
-	/**
 	 * Create a new functional list with the specified size.
 	 * 
 	 * @param size
@@ -102,26 +82,18 @@ public class FunctionalList<E> implements Cloneable {
 		wrappedList = backingList;
 	}
 
-	/**
-	 * Add an item to this list
-	 * 
-	 * @param item
-	 *            The item to add to this list.
-	 * @return Whether the item was added to the list succesfully.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#add(E)
 	 */
+	@Override
 	public boolean add(E item) {
 		return wrappedList.add(item);
 	}
 
-	/**
-	 * Check if all of the elements of this list match the specified
-	 * predicate.
-	 * 
-	 * @param matchPredicate
-	 *            The predicate to use for checking.
-	 * @return Whether all of the elements of the list match the specified
-	 *         predicate.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#allMatch(java.util.function.Predicate)
 	 */
+	@Override
 	public boolean allMatch(Predicate<E> matchPredicate) {
 		if (matchPredicate == null) {
 			throw new NullPointerException("Predicate must be non-null");
@@ -138,14 +110,10 @@ public class FunctionalList<E> implements Cloneable {
 		return true;
 	}
 
-	/**
-	 * Check if any of the elements in this list match the specified list.
-	 * 
-	 * @param matchPredicate
-	 *            The predicate to use for checking.
-	 * @return Whether any element in the list matches the provided
-	 *         predicate.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#anyMatch(java.util.function.Predicate)
 	 */
+	@Override
 	public boolean anyMatch(Predicate<E> matchPredicate) {
 		if (matchPredicate == null) {
 			throw new NullPointerException("Predicate must be not null");
@@ -163,8 +131,8 @@ public class FunctionalList<E> implements Cloneable {
 	}
 
 	@Override
-	public FunctionalList<E> clone() {
-		FunctionalList<E> clonedList = new FunctionalList<>();
+	public IFunctionalList<E> clone() {
+		IFunctionalList<E> clonedList = new FunctionalList<>();
 
 		for (E element : wrappedList) {
 			clonedList.add(element);
@@ -173,27 +141,12 @@ public class FunctionalList<E> implements Cloneable {
 		return clonedList;
 	}
 
-	/**
-	 * Combine this list with another one into a new list and merge the
-	 * results. Works sort of like a combined zip/map over resulting pairs.
-	 * Does not change the underlying list.
-	 * 
-	 * NOTE: The returned list will have the length of the shorter of this
-	 * list and the combined one.
-	 * 
-	 * @param <T>
-	 *            The type of the second list
-	 * @param <F>
-	 *            The type of the combined list
-	 * 
-	 * @param rightList
-	 *            The list to combine with
-	 * @param itemCombiner
-	 *            The function to use for combining element pairs.
-	 * @return A new list containing the merged pairs of lists.
-	 */
-	public <T, F> FunctionalList<F> combineWith(
-			FunctionalList<T> rightList,
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#combineWith(bjc.utils.funcdata.IFunctionalList, java.util.function.BiFunction)
+	 */
+	@Override
+	public <T, F> IFunctionalList<F> combineWith(
+			IFunctionalList<T> rightList,
 			BiFunction<E, T, F> itemCombiner) {
 		if (rightList == null) {
 			throw new NullPointerException(
@@ -202,7 +155,7 @@ public class FunctionalList<E> implements Cloneable {
 			throw new NullPointerException("Combiner must not be null");
 		}
 
-		FunctionalList<F> returnedList = new FunctionalList<>();
+		IFunctionalList<F> returnedList = new FunctionalList<>();
 
 		// Get the iterator for the other list
 		Iterator<T> rightIterator = rightList.toIterable().iterator();
@@ -220,23 +173,19 @@ public class FunctionalList<E> implements Cloneable {
 		return returnedList;
 	}
 
-	/**
-	 * Check if the list contains the specified item
-	 * 
-	 * @param item
-	 *            The item to see if it is contained
-	 * @return Whether or not the specified item is in the list
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#contains(E)
 	 */
+	@Override
 	public boolean contains(E item) {
 		// Check if any items in the list match the provided item
 		return this.anyMatch(item::equals);
 	}
 
-	/**
-	 * Get the first element in the list
-	 * 
-	 * @return The first element in this list.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#first()
 	 */
+	@Override
 	public E first() {
 		if (wrappedList.size() < 1) {
 			throw new NoSuchElementException(
@@ -246,29 +195,21 @@ public class FunctionalList<E> implements Cloneable {
 		return wrappedList.get(0);
 	}
 
-	/**
-	 * Apply a function to each member of the list, then flatten the
-	 * results. Does not change the underlying list.
-	 * 
-	 * @param <T>
-	 *            The type of the flattened list
-	 * 
-	 * @param elementExpander
-	 *            The function to apply to each member of the list.
-	 * @return A new list containing the flattened results of applying the
-	 *         provided function.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#flatMap(java.util.function.Function)
 	 */
-	public <T> FunctionalList<T> flatMap(
-			Function<E, FunctionalList<T>> elementExpander) {
+	@Override
+	public <T> IFunctionalList<T> flatMap(
+			Function<E, IFunctionalList<T>> elementExpander) {
 		if (elementExpander == null) {
 			throw new NullPointerException("Expander must not be null");
 		}
 
-		FunctionalList<T> returnedList = new FunctionalList<>(
+		IFunctionalList<T> returnedList = new FunctionalList<>(
 				this.wrappedList.size());
 
 		forEach(element -> {
-			FunctionalList<T> expandedElement = elementExpander
+			IFunctionalList<T> expandedElement = elementExpander
 					.apply(element);
 
 			if (expandedElement == null) {
@@ -283,12 +224,10 @@ public class FunctionalList<E> implements Cloneable {
 		return returnedList;
 	}
 
-	/**
-	 * Apply a given action for each member of the list
-	 * 
-	 * @param action
-	 *            The action to apply to each member of the list.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#forEach(java.util.function.Consumer)
 	 */
+	@Override
 	public void forEach(Consumer<E> action) {
 		if (action == null) {
 			throw new NullPointerException("Action is null");
@@ -297,13 +236,10 @@ public class FunctionalList<E> implements Cloneable {
 		wrappedList.forEach(action);
 	}
 
-	/**
-	 * Apply a given function to each element in the list and its index.
-	 * 
-	 * @param indexedAction
-	 *            The function to apply to each element in the list and its
-	 *            index.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#forEachIndexed(java.util.function.BiConsumer)
 	 */
+	@Override
 	public void forEachIndexed(BiConsumer<Integer, E> indexedAction) {
 		if (indexedAction == null) {
 			throw new NullPointerException("Action must not be null");
@@ -322,13 +258,10 @@ public class FunctionalList<E> implements Cloneable {
 		});
 	}
 
-	/**
-	 * Retrieve a value in the list by its index.
-	 * 
-	 * @param index
-	 *            The index to retrieve a value from.
-	 * @return The value at the specified index in the list.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#getByIndex(int)
 	 */
+	@Override
 	public E getByIndex(int index) {
 		return wrappedList.get(index);
 	}
@@ -342,19 +275,16 @@ public class FunctionalList<E> implements Cloneable {
 		return wrappedList;
 	}
 
-	/**
-	 * Retrieve a list containing all elements matching a predicate
-	 * 
-	 * @param matchPredicate
-	 *            The predicate to match by
-	 * @return A list containing all elements that match the predicate
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#getMatching(java.util.function.Predicate)
 	 */
-	public FunctionalList<E> getMatching(Predicate<E> matchPredicate) {
+	@Override
+	public IFunctionalList<E> getMatching(Predicate<E> matchPredicate) {
 		if (matchPredicate == null) {
 			throw new NullPointerException("Predicate must not be null");
 		}
 
-		FunctionalList<E> returnedList = new FunctionalList<>();
+		IFunctionalList<E> returnedList = new FunctionalList<>();
 
 		wrappedList.forEach((element) -> {
 			if (matchPredicate.test(element)) {
@@ -366,41 +296,32 @@ public class FunctionalList<E> implements Cloneable {
 		return returnedList;
 	}
 
-	/**
-	 * Retrieve the size of the wrapped list
-	 * 
-	 * @return The size of the wrapped list
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#getSize()
 	 */
+	@Override
 	public int getSize() {
 		return wrappedList.size();
 	}
 
-	/**
-	 * Check if this list is empty.
-	 * 
-	 * @return Whether or not this list is empty.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#isEmpty()
 	 */
+	@Override
 	public boolean isEmpty() {
 		return wrappedList.isEmpty();
 	}
 
-	/**
-	 * Create a new list by applying the given function to each element in
-	 * the list. Does not change the underlying list.
-	 * 
-	 * @param <T>
-	 *            The type of the transformed list
-	 * 
-	 * @param elementTransformer
-	 *            The function to apply to each element in the list
-	 * @return A new list containing the mapped elements of this list.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#map(java.util.function.Function)
 	 */
-	public <T> FunctionalList<T> map(Function<E, T> elementTransformer) {
+	@Override
+	public <T> IFunctionalList<T> map(Function<E, T> elementTransformer) {
 		if (elementTransformer == null) {
 			throw new NullPointerException("Transformer must be not null");
 		}
 
-		FunctionalList<T> returnedList = new FunctionalList<>(
+		IFunctionalList<T> returnedList = new FunctionalList<>(
 				this.wrappedList.size());
 
 		forEach(element -> {
@@ -411,30 +332,20 @@ public class FunctionalList<E> implements Cloneable {
 		return returnedList;
 	}
 
-	/**
-	 * Zip two lists into a list of pairs
-	 * 
-	 * @param <T>
-	 *            The type of the second list
-	 * 
-	 * @param rightList
-	 *            The list to use as the left side of the pair
-	 * @return A list containing pairs of this element and the specified
-	 *         list
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#pairWith(bjc.utils.funcdata.IFunctionalList)
 	 */
-	public <T> FunctionalList<Pair<E, T>> pairWith(
-			FunctionalList<T> rightList) {
+	@Override
+	public <T> IFunctionalList<IPair<E, T>> pairWith(
+			IFunctionalList<T> rightList) {
 		return combineWith(rightList, Pair<E, T>::new);
 	}
 
-	/**
-	 * Partition this list into a list of sublists
-	 * 
-	 * @param numberPerPartition
-	 *            The size of elements to put into each one of the sublists
-	 * @return A list partitioned into partitions of size nPerPart
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#partition(int)
 	 */
-	public FunctionalList<FunctionalList<E>> partition(
+	@Override
+	public IFunctionalList<IFunctionalList<E>> partition(
 			int numberPerPartition) {
 		if (numberPerPartition < 1
 				|| numberPerPartition > wrappedList.size()) {
@@ -443,10 +354,10 @@ public class FunctionalList<E> implements Cloneable {
 					+ wrappedList.size());
 		}
 
-		FunctionalList<FunctionalList<E>> returnedList = new FunctionalList<>();
+		IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>();
 
 		// The current partition being filled
-		GenHolder<FunctionalList<E>> currentPartition = new GenHolder<>(
+		GenHolder<IFunctionalList<E>> currentPartition = new GenHolder<>(
 				new FunctionalList<>());
 
 		this.forEach((element) -> {
@@ -472,29 +383,23 @@ public class FunctionalList<E> implements Cloneable {
 	 * Check if a partition has room for another item
 	 */
 	private Boolean isPartitionFull(int numberPerPartition,
-			GenHolder<FunctionalList<E>> currentPartition) {
+			GenHolder<IFunctionalList<E>> currentPartition) {
 		return currentPartition.unwrap(
 				(partition) -> partition.getSize() >= numberPerPartition);
 	}
 
-	/**
-	 * Prepend an item to the list
-	 * 
-	 * @param item
-	 *            The item to prepend to the list
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#prepend(E)
 	 */
+	@Override
 	public void prepend(E item) {
 		wrappedList.add(0, item);
 	}
 
-	/**
-	 * Select a random item from this list, using the provided random
-	 * number generator.
-	 * 
-	 * @param rnd
-	 *            The random number generator to use.
-	 * @return A random element from this list.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#randItem(java.util.Random)
 	 */
+	@Override
 	public E randItem(Random rnd) {
 		if (rnd == null) {
 			throw new NullPointerException(
@@ -506,25 +411,10 @@ public class FunctionalList<E> implements Cloneable {
 		return wrappedList.get(randomIndex);
 	}
 
-	/**
-	 * Reduce this list to a single value, using a accumulative approach.
-	 * 
-	 * @param <T>
-	 *            The in-between type of the values
-	 * @param <F>
-	 *            The final value type
-	 * 
-	 * @param initialValue
-	 *            The initial value of the accumulative state.
-	 * @param stateAccumulator
-	 *            The function to use to combine a list element with the
-	 *            accumulative state.
-	 * @param resultTransformer
-	 *            The function to use to convert the accumulative state
-	 *            into a final result.
-	 * @return A single value condensed from this list and transformed into
-	 *         its final state.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#reduceAux(T, java.util.function.BiFunction, java.util.function.Function)
 	 */
+	@Override
 	public <T, F> F reduceAux(T initialValue,
 			BiFunction<E, T, T> stateAccumulator,
 			Function<T, F> resultTransformer) {
@@ -547,13 +437,10 @@ public class FunctionalList<E> implements Cloneable {
 		return currentState.unwrap(resultTransformer);
 	}
 
-	/**
-	 * Remove all elements that match a given predicate
-	 * 
-	 * @param removePredicate
-	 *            The predicate to use to determine elements to delete
-	 * @return Whether there was anything that satisfied the predicate
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#removeIf(java.util.function.Predicate)
 	 */
+	@Override
 	public boolean removeIf(Predicate<E> removePredicate) {
 		if (removePredicate == null) {
 			throw new NullPointerException("Predicate must be non-null");
@@ -562,28 +449,18 @@ public class FunctionalList<E> implements Cloneable {
 		return wrappedList.removeIf(removePredicate);
 	}
 
-	/**
-	 * Remove all parameters that match a given parameter
-	 * 
-	 * @param desiredElement
-	 *            The object to remove all matching copies of
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#removeMatching(E)
 	 */
+	@Override
 	public void removeMatching(E desiredElement) {
 		removeIf((element) -> element.equals(desiredElement));
 	}
 
-	/**
-	 * Perform a binary search for the specified key using the provided
-	 * means of comparing elements. Since this IS a binary search, the list
-	 * must have been sorted before hand.
-	 * 
-	 * @param searchKey
-	 *            The key to search for.
-	 * @param comparator
-	 *            The way to compare elements for searching. Pass null to
-	 *            use the natural ordering for E
-	 * @return The element if it is in this list, or null if it is not.
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#search(E, java.util.Comparator)
 	 */
+	@Override
 	public E search(E searchKey, Comparator<E> comparator) {
 		// Search our internal list
 		int foundIndex = Collections.binarySearch(wrappedList, searchKey,
@@ -598,23 +475,18 @@ public class FunctionalList<E> implements Cloneable {
 		return null;
 	}
 
-	/**
-	 * Sort the elements of this list using the provided way of comparing
-	 * elements. Does change the underlying list.
-	 * 
-	 * @param comparator
-	 *            The way to compare elements for sorting. Pass null to use
-	 *            E's natural ordering
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#sort(java.util.Comparator)
 	 */
+	@Override
 	public void sort(Comparator<E> comparator) {
 		Collections.sort(wrappedList, comparator);
 	}
 
-	/**
-	 * Convert the list into a iterable
-	 * 
-	 * @return An iterable view onto the list
+	/* (non-Javadoc)
+	 * @see bjc.utils.funcdata.IFunctionalList#toIterable()
 	 */
+	@Override
 	public Iterable<E> toIterable() {
 		return wrappedList;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
index 0453988..fc4c4de 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalMap.java
@@ -2,27 +2,40 @@ package bjc.utils.funcdata;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.BiConsumer;
 import java.util.function.Function;
 
 import bjc.utils.data.Pair;
 
 /**
- * Functional wrapper over map providing some useful things
+ * Basic implementation of {@link IFunctionalMap}
  * 
  * @author ben
- * 
+ *
  * @param <K>
- *            The type of this map's keys
+ *            The type of the map's keys
  * @param <V>
- *            The type of this map's values
- *
+ *            The type of the map's values
  */
-public class FunctionalMap<K, V> {
-	private final class TransformedMap<V2> extends FunctionalMap<K, V2> {
-		private FunctionalMap<K, V>	mapToTransform;
-		private Function<V, V2>		transformer;
+public class FunctionalMap<K, V> implements IFunctionalMap<K, V> {
+	/**
+	 * A map that transforms values from one type to another
+	 * 
+	 * @author ben
+	 *
+	 * @param <K>
+	 *            The type of the map's keys
+	 * @param <V>
+	 *            The type of the map's values
+	 * @param <V2>
+	 *            The type of the transformed values
+	 */
+	private static final class TransformedValueMap<K, V, V2>
+			implements IFunctionalMap<K, V2> {
+		private IFunctionalMap<K, V>	mapToTransform;
+		private Function<V, V2>			transformer;
 
-		public TransformedMap(FunctionalMap<K, V> destMap,
+		public TransformedValueMap(IFunctionalMap<K, V> destMap,
 				Function<V, V2> transform) {
 			mapToTransform = destMap;
 			transformer = transform;
@@ -42,6 +55,40 @@ public class FunctionalMap<K, V> {
 		public String toString() {
 			return mapToTransform.toString();
 		}
+
+		@Override
+		public V2 put(K key, V2 val) {
+			throw new UnsupportedOperationException(
+					"Can't add items to transformed map");
+		}
+
+		@Override
+		public <V3> IFunctionalMap<K, V3> mapValues(
+				Function<V2, V3> transform) {
+			return new TransformedValueMap<>(this, transform);
+		}
+
+		@Override
+		public IFunctionalList<K> keyList() {
+			return mapToTransform.keyList();
+		}
+
+		@Override
+		public void forEach(BiConsumer<K, V2> action) {
+			mapToTransform.forEach((key, val) -> {
+				action.accept(key, transformer.apply(val));
+			});
+		}
+
+		@Override
+		public V2 remove(K key) {
+			return transformer.apply(mapToTransform.remove(key));
+		}
+
+		@Override
+		public int getSize() {
+			return mapToTransform.getSize();
+		}
 	}
 
 	private Map<K, V> wrappedMap;
@@ -84,18 +131,12 @@ public class FunctionalMap<K, V> {
 		}
 	}
 
-	/**
-	 * Add an entry to the map
-	 * 
-	 * @param key
-	 *            The key to put the value under
-	 * @param val
-	 *            The value to add
-	 * @return The previous value of the key in the map, or null if the key
-	 *         wasn't in the map. However, note that it may also return
-	 *         null if the key was set to null.
+	/*
+	 * (non-Javadoc)
 	 * 
+	 * @see bjc.utils.funcdata.IFunctionalMap#put(K, V)
 	 */
+	@Override
 	public V put(K key, V val) {
 		if (key == null) {
 			throw new NullPointerException("Key must not be null");
@@ -104,15 +145,12 @@ public class FunctionalMap<K, V> {
 		return wrappedMap.put(key, val);
 	}
 
-	/**
-	 * Get the value assigned to the given key
-	 * 
-	 * @param key
-	 *            The key to look for a value under
-	 * @return The value of the key
-	 * 
+	/*
+	 * (non-Javadoc)
 	 * 
+	 * @see bjc.utils.funcdata.IFunctionalMap#get(K)
 	 */
+	@Override
 	public V get(K key) {
 		if (key == null) {
 			throw new NullPointerException("Key must not be null");
@@ -126,35 +164,28 @@ public class FunctionalMap<K, V> {
 		return wrappedMap.get(key);
 	}
 
-	/**
-	 * Transform the values returned by this map.
+	/*
+	 * (non-Javadoc)
 	 * 
-	 * NOTE: This transform is applied once for each lookup of a value, so
-	 * the transform passed should be a proper function, or things will
-	 * likely not work as expected.
-	 * 
-	 * @param <V2>
-	 *            The new type of returned values
-	 * @param transformer
-	 *            The function to use to transform values
-	 * @return The map where each value will be transformed after lookup
+	 * @see bjc.utils.funcdata.IFunctionalMap#mapValues(java.util.function.
+	 * Function)
 	 */
-	public <V2> FunctionalMap<K, V2> mapValues(
+	@Override
+	public <V2> IFunctionalMap<K, V2> mapValues(
 			Function<V, V2> transformer) {
 		if (transformer == null) {
 			throw new NullPointerException("Transformer must not be null");
 		}
 
-		return new TransformedMap<>(this, transformer);
+		return new TransformedValueMap<>(this, transformer);
 	}
 
-	/**
-	 * Check if this map contains the specified key
+	/*
+	 * (non-Javadoc)
 	 * 
-	 * @param key
-	 *            The key to check
-	 * @return Whether or not the map contains the key
+	 * @see bjc.utils.funcdata.IFunctionalMap#containsKey(K)
 	 */
+	@Override
 	public boolean containsKey(K key) {
 		return wrappedMap.containsKey(key);
 	}
@@ -163,4 +194,30 @@ public class FunctionalMap<K, V> {
 	public String toString() {
 		return wrappedMap.toString();
 	}
+
+	@Override
+	public IFunctionalList<K> keyList() {
+		FunctionalList<K> keys = new FunctionalList<>();
+
+		wrappedMap.keySet().forEach((key) -> {
+			keys.add(key);
+		});
+
+		return keys;
+	}
+
+	@Override
+	public void forEach(BiConsumer<K, V> action) {
+		wrappedMap.forEach(action);
+	}
+
+	@Override
+	public V remove(K key) {
+		return wrappedMap.remove(key);
+	}
+
+	@Override
+	public int getSize() {
+		return wrappedMap.size();
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
index 9ef59fb..0e2d199 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/FunctionalStringTokenizer.java
@@ -137,13 +137,13 @@ public class FunctionalStringTokenizer {
 	 *            The function to use to convert tokens.
 	 * @return A list containing all of the converted tokens.
 	 */
-	public <E> FunctionalList<E> toList(
+	public <E> IFunctionalList<E> toList(
 			Function<String, E> tokenTransformer) {
 		if (tokenTransformer == null) {
 			throw new NullPointerException("Transformer must not be null");
 		}
 
-		FunctionalList<E> returnList = new FunctionalList<>();
+		IFunctionalList<E> returnList = new FunctionalList<>();
 
 		// Add each token to the list after transforming it
 		forEachToken(token -> {
@@ -160,7 +160,7 @@ public class FunctionalStringTokenizer {
 	 * 
 	 * @return This tokenizer, converted into a list of strings
 	 */
-	public FunctionalList<String> toList() {
+	public IFunctionalList<String> toList() {
 		return toList((String element) -> element);
 	}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java
new file mode 100644
index 0000000..a017aa9
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java
@@ -0,0 +1,281 @@
+package bjc.utils.funcdata;
+
+import java.util.Comparator;
+import java.util.Random;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import bjc.utils.data.IPair;
+
+/**
+ * A wrapper over another list that provides eager functional operations
+ * over it. Differs from a stream in every way except for the fact that
+ * they both provide functional operations.
+ * 
+ * @author ben
+ *
+ * @param <E>
+ *            The type in this list
+ */
+public interface IFunctionalList<E> {
+
+	/**
+	 * Add an item to this list
+	 * 
+	 * @param item
+	 *            The item to add to this list.
+	 * @return Whether the item was added to the list succesfully.
+	 */
+	boolean add(E item);
+
+	/**
+	 * Check if all of the elements of this list match the specified
+	 * predicate.
+	 * 
+	 * @param matchPredicate
+	 *            The predicate to use for checking.
+	 * @return Whether all of the elements of the list match the specified
+	 *         predicate.
+	 */
+	boolean allMatch(Predicate<E> matchPredicate);
+
+	/**
+	 * Check if any of the elements in this list match the specified list.
+	 * 
+	 * @param matchPredicate
+	 *            The predicate to use for checking.
+	 * @return Whether any element in the list matches the provided
+	 *         predicate.
+	 */
+	boolean anyMatch(Predicate<E> matchPredicate);
+
+	/**
+	 * Combine this list with another one into a new list and merge the
+	 * results. Works sort of like a combined zip/map over resulting pairs.
+	 * Does not change the underlying list.
+	 * 
+	 * NOTE: The returned list will have the length of the shorter of this
+	 * list and the combined one.
+	 * 
+	 * @param <T>
+	 *            The type of the second list
+	 * @param <F>
+	 *            The type of the combined list
+	 * 
+	 * @param rightList
+	 *            The list to combine with
+	 * @param itemCombiner
+	 *            The function to use for combining element pairs.
+	 * @return A new list containing the merged pairs of lists.
+	 */
+	<T, F> IFunctionalList<F> combineWith(IFunctionalList<T> rightList,
+			BiFunction<E, T, F> itemCombiner);
+
+	/**
+	 * Check if the list contains the specified item
+	 * 
+	 * @param item
+	 *            The item to see if it is contained
+	 * @return Whether or not the specified item is in the list
+	 */
+	boolean contains(E item);
+
+	/**
+	 * Get the first element in the list
+	 * 
+	 * @return The first element in this list.
+	 */
+	E first();
+
+	/**
+	 * Apply a function to each member of the list, then flatten the
+	 * results. Does not change the underlying list.
+	 * 
+	 * @param <T>
+	 *            The type of the flattened list
+	 * 
+	 * @param elementExpander
+	 *            The function to apply to each member of the list.
+	 * @return A new list containing the flattened results of applying the
+	 *         provided function.
+	 */
+	<T> IFunctionalList<T> flatMap(
+			Function<E, IFunctionalList<T>> elementExpander);
+
+	/**
+	 * Apply a given action for each member of the list
+	 * 
+	 * @param action
+	 *            The action to apply to each member of the list.
+	 */
+	void forEach(Consumer<E> action);
+
+	/**
+	 * Apply a given function to each element in the list and its index.
+	 * 
+	 * @param indexedAction
+	 *            The function to apply to each element in the list and its
+	 *            index.
+	 */
+	void forEachIndexed(BiConsumer<Integer, E> indexedAction);
+
+	/**
+	 * Retrieve a value in the list by its index.
+	 * 
+	 * @param index
+	 *            The index to retrieve a value from.
+	 * @return The value at the specified index in the list.
+	 */
+	E getByIndex(int index);
+
+	/**
+	 * Retrieve a list containing all elements matching a predicate
+	 * 
+	 * @param matchPredicate
+	 *            The predicate to match by
+	 * @return A list containing all elements that match the predicate
+	 */
+	IFunctionalList<E> getMatching(Predicate<E> matchPredicate);
+
+	/**
+	 * Retrieve the size of the wrapped list
+	 * 
+	 * @return The size of the wrapped list
+	 */
+	int getSize();
+
+	/**
+	 * Check if this list is empty.
+	 * 
+	 * @return Whether or not this list is empty.
+	 */
+	boolean isEmpty();
+
+	/**
+	 * Create a new list by applying the given function to each element in
+	 * the list. Does not change the underlying list.
+	 * 
+	 * @param <T>
+	 *            The type of the transformed list
+	 * 
+	 * @param elementTransformer
+	 *            The function to apply to each element in the list
+	 * @return A new list containing the mapped elements of this list.
+	 */
+	<T> IFunctionalList<T> map(Function<E, T> elementTransformer);
+
+	/**
+	 * Zip two lists into a list of pairs
+	 * 
+	 * @param <T>
+	 *            The type of the second list
+	 * 
+	 * @param rightList
+	 *            The list to use as the left side of the pair
+	 * @return A list containing pairs of this element and the specified
+	 *         list
+	 */
+	<T> IFunctionalList<IPair<E, T>> pairWith(
+			IFunctionalList<T> rightList);
+
+	/**
+	 * Partition this list into a list of sublists
+	 * 
+	 * @param numberPerPartition
+	 *            The size of elements to put into each one of the sublists
+	 * @return A list partitioned into partitions of size nPerPart
+	 */
+	IFunctionalList<IFunctionalList<E>> partition(int numberPerPartition);
+
+	/**
+	 * Prepend an item to the list
+	 * 
+	 * @param item
+	 *            The item to prepend to the list
+	 */
+	void prepend(E item);
+
+	/**
+	 * Select a random item from this list, using the provided random
+	 * number generator.
+	 * 
+	 * @param rnd
+	 *            The random number generator to use.
+	 * @return A random element from this list.
+	 */
+	E randItem(Random rnd);
+
+	/**
+	 * Reduce this list to a single value, using a accumulative approach.
+	 * 
+	 * @param <T>
+	 *            The in-between type of the values
+	 * @param <F>
+	 *            The final value type
+	 * 
+	 * @param initialValue
+	 *            The initial value of the accumulative state.
+	 * @param stateAccumulator
+	 *            The function to use to combine a list element with the
+	 *            accumulative state.
+	 * @param resultTransformer
+	 *            The function to use to convert the accumulative state
+	 *            into a final result.
+	 * @return A single value condensed from this list and transformed into
+	 *         its final state.
+	 */
+	<T, F> F reduceAux(T initialValue,
+			BiFunction<E, T, T> stateAccumulator,
+			Function<T, F> resultTransformer);
+
+	/**
+	 * Remove all elements that match a given predicate
+	 * 
+	 * @param removePredicate
+	 *            The predicate to use to determine elements to delete
+	 * @return Whether there was anything that satisfied the predicate
+	 */
+	boolean removeIf(Predicate<E> removePredicate);
+
+	/**
+	 * Remove all parameters that match a given parameter
+	 * 
+	 * @param desiredElement
+	 *            The object to remove all matching copies of
+	 */
+	void removeMatching(E desiredElement);
+
+	/**
+	 * Perform a binary search for the specified key using the provided
+	 * means of comparing elements. Since this IS a binary search, the list
+	 * must have been sorted before hand.
+	 * 
+	 * @param searchKey
+	 *            The key to search for.
+	 * @param comparator
+	 *            The way to compare elements for searching. Pass null to
+	 *            use the natural ordering for E
+	 * @return The element if it is in this list, or null if it is not.
+	 */
+	E search(E searchKey, Comparator<E> comparator);
+
+	/**
+	 * Sort the elements of this list using the provided way of comparing
+	 * elements. Does change the underlying list.
+	 * 
+	 * @param comparator
+	 *            The way to compare elements for sorting. Pass null to use
+	 *            E's natural ordering
+	 */
+	void sort(Comparator<E> comparator);
+
+	/**
+	 * Convert the list into a iterable
+	 * 
+	 * @return An iterable view onto the list
+	 */
+	Iterable<E> toIterable();
+}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalMap.java
new file mode 100644
index 0000000..9bd62bc
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalMap.java
@@ -0,0 +1,104 @@
+package bjc.utils.funcdata;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+/**
+ * Functional wrapper over map providing some useful things
+ * 
+ * @author ben
+ * 
+ * @param <K>
+ *            The type of this map's keys
+ * @param <V>
+ *            The type of this map's values
+ *
+ */
+public interface IFunctionalMap<K, V> {
+
+	/**
+	 * Add an entry to the map
+	 * 
+	 * @param key
+	 *            The key to put the value under
+	 * @param val
+	 *            The value to add
+	 * @return The previous value of the key in the map, or null if the key
+	 *         wasn't in the map. However, note that it may also return
+	 *         null if the key was set to null.
+	 * 
+	 * @throws UnsupportedOperationException
+	 *             if the map implementation doesn't support modifying the
+	 *             map
+	 */
+	V put(K key, V val);
+
+	/**
+	 * Get the value assigned to the given key
+	 * 
+	 * @param key
+	 *            The key to look for a value under
+	 * @return The value of the key
+	 * 
+	 * 
+	 */
+	V get(K key);
+
+	/**
+	 * Transform the values returned by this map.
+	 * 
+	 * NOTE: This transform is applied once for each lookup of a value, so
+	 * the transform passed should be a proper function, or things will
+	 * likely not work as expected.
+	 * 
+	 * @param <V2>
+	 *            The new type of returned values
+	 * @param transformer
+	 *            The function to use to transform values
+	 * @return The map where each value will be transformed after lookup
+	 */
+	<V2> IFunctionalMap<K, V2> mapValues(Function<V, V2> transformer);
+
+	/**
+	 * Check if this map contains the specified key
+	 * 
+	 * @param key
+	 *            The key to check
+	 * @return Whether or not the map contains the key
+	 */
+	boolean containsKey(K key);
+
+	/**
+	 * Get a list of all the keys in this map
+	 * 
+	 * @return A list of all the keys in this map
+	 */
+	IFunctionalList<K> keyList();
+
+	/**
+	 * Execute an action for each entry in the map
+	 * 
+	 * @param action
+	 *            the action to execute for each entry in the map
+	 */
+	void forEach(BiConsumer<K, V> action);
+
+	/**
+	 * Remove the value bound to the key
+	 * 
+	 * @param key
+	 *            The key to remove from the map
+	 * @return The previous value for the key in the map, or null if the
+	 *         key wasn't in the class. NOTE: Just because you recieved
+	 *         null, doesn't mean the map wasn't changed. It may mean that
+	 *         someone put a null value for that key into the map
+	 */
+	V remove(K key);
+
+	/**
+	 * Get the number of entries in this map
+	 * 
+	 * @return The number of entries in this map
+	 */
+	int getSize();
+}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
index fa92f85..67b9985 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/bst/BinarySearchTree.java
@@ -6,6 +6,7 @@ import java.util.List;
 import java.util.function.Predicate;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.funcdata.bst.ITreePart.TreeLinearizationMethod;
 
 /**
@@ -68,7 +69,7 @@ public class BinarySearchTree<T> {
 	 * time, but also O(N) space.
 	 */
 	public void balance() {
-		FunctionalList<T> elements = new FunctionalList<>();
+		IFunctionalList<T> elements = new FunctionalList<>();
 
 		// Add each element to the list in sorted order
 		rootElement.forEach(TreeLinearizationMethod.INORDER,
@@ -123,7 +124,7 @@ public class BinarySearchTree<T> {
 	 *            The distance from the pivot
 	 * @return Whether the adjusted pivot is with the list
 	 */
-	private boolean adjustedPivotInBounds(FunctionalList<T> elements,
+	private boolean adjustedPivotInBounds(IFunctionalList<T> elements,
 			int pivot, int pivotAdjustment) {
 		return (pivot - pivotAdjustment) >= 0
 				&& (pivot + pivotAdjustment) < elements.getSize();
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java
new file mode 100644
index 0000000..f490727
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/EnumUtils.java
@@ -0,0 +1,64 @@
+package bjc.utils.funcutils;
+
+import java.util.Random;
+import java.util.function.Consumer;
+
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
+
+/**
+ * Utility methods on enums
+ * 
+ * @author ben
+ *
+ */
+public class EnumUtils {
+	/**
+	 * Get a random value from an enum
+	 * 
+	 * @param <E>
+	 *            The type of the enum
+	 * @param enumClass
+	 *            The class of the enum
+	 * @param rnd
+	 *            The random source to use
+	 * @return A random value from the specified enum
+	 */
+	public static <E extends Enum<E>> E getRandomValue(Class<E> enumClass,
+			Random rnd) {
+		E[] enumValues = enumClass.getEnumConstants();
+
+		return new FunctionalList<>(enumValues).randItem(rnd);
+	}
+
+	/**
+	 * Do an action for a random number of enum values
+	 * 
+	 * @param <E>
+	 *            The type of the enum
+	 * @param enumClass
+	 *            The enum class
+	 * @param nValues
+	 *            The number of values to execute the action on
+	 * @param action
+	 *            The action to perform on random values
+	 * @param rnd
+	 *            The source of randomness to use
+	 */
+	public static <E extends Enum<E>> void doForValues(Class<E> enumClass,
+			int nValues, Consumer<E> action, Random rnd) {
+		E[] enumValues = enumClass.getEnumConstants();
+
+		IFunctionalList<E> valueList = new FunctionalList<>(enumValues);
+
+		int randomValueCount = enumValues.length - nValues;
+
+		for (int i = 0; i <= randomValueCount; i++) {
+			E rDir = valueList.randItem(rnd);
+
+			valueList.removeMatching(rDir);
+		}
+
+		valueList.forEach(action);
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java
new file mode 100644
index 0000000..fd09fbb
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FileUtils.java
@@ -0,0 +1,77 @@
+package bjc.utils.funcutils;
+
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.function.BiPredicate;
+
+/**
+ * Utilities for doing things with files
+ * 
+ * @author ben
+ *
+ */
+public class FileUtils {
+	private static final class FunctionalFileVisitor
+			extends SimpleFileVisitor<Path> {
+		private BiPredicate<Path, BasicFileAttributes>	traversalPredicate;
+		private BiPredicate<Path, BasicFileAttributes>	traversalAction;
+
+		public FunctionalFileVisitor(
+				BiPredicate<Path, BasicFileAttributes> traversalPredicate,
+				BiPredicate<Path, BasicFileAttributes> traversalAction) {
+			this.traversalPredicate = traversalPredicate;
+			this.traversalAction = traversalAction;
+		}
+
+		@Override
+		public FileVisitResult preVisitDirectory(Path dir,
+				BasicFileAttributes attrs) throws IOException {
+			if (traversalPredicate.test(dir, attrs)) {
+				return FileVisitResult.CONTINUE;
+			}
+
+			return FileVisitResult.SKIP_SUBTREE;
+		}
+
+		@Override
+		public FileVisitResult visitFile(Path file,
+				BasicFileAttributes attrs) throws IOException {
+			if (traversalAction.test(file, attrs)) {
+				return FileVisitResult.CONTINUE;
+			}
+
+			return FileVisitResult.TERMINATE;
+		}
+	}
+
+	/**
+	 * Traverse a directory recursively. This is a depth-first traversal
+	 * 
+	 * 
+	 * @param root
+	 *            The directory to start the traversal at
+	 * @param traversalPredicate
+	 *            The predicate to determine whether or not to traverse a
+	 *            directory
+	 * @param traversalAction
+	 *            The action to invoke upon each file in the directory.
+	 *            Returning true means to continue the traversal, returning
+	 *            false stops it
+	 * @throws IOException
+	 *             if the walk throws an exception
+	 * 
+	 *             TODO If it becomes necessary, write another overload for
+	 *             this with all the buttons and knobs from walkFileTree
+	 */
+	public static void traverseDirectory(Path root,
+			BiPredicate<Path, BasicFileAttributes> traversalPredicate,
+			BiPredicate<Path, BasicFileAttributes> traversalAction)
+			throws IOException {
+		Files.walkFileTree(root, new FunctionalFileVisitor(
+				traversalPredicate, traversalAction));
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
new file mode 100644
index 0000000..d89b7da
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/FuncUtils.java
@@ -0,0 +1,44 @@
+package bjc.utils.funcutils;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+
+/**
+ * Utility things for functions
+ * 
+ * @author ben
+ *
+ */
+public class FuncUtils {
+	/**
+	 * Do the specified action the specified number of times
+	 * 
+	 * @param nTimes
+	 *            The number of times to do the action
+	 * @param cons
+	 *            The action to perform
+	 */
+	public static void doTimes(int nTimes, IntConsumer cons) {
+		for (int i = 0; i < nTimes; i++) {
+			cons.accept(i);
+		}
+	}
+
+	/**
+	 * Convert a binary function into a unary function that returns a
+	 * function
+	 * 
+	 * @param <A> The initial type of the function
+	 * @param <B> The intermediate type of the function
+	 * @param <C> The terminal type of the function
+	 * @param func The function to transform
+	 * @return The function transformed into a unary function returning a function
+	 */
+	public static <A, B, C> Function<A, Function<B, C>> curry2(
+			BiFunction<A, B, C> func) {
+		return (arg1) -> (arg2) -> {
+			return func.apply(arg1, arg2);
+		};
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
index 1d2750b..871e1cf 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/ListUtils.java
@@ -6,8 +6,9 @@ import java.util.function.Consumer;
 import java.util.function.Function;
 
 import bjc.utils.data.GenHolder;
-import bjc.utils.data.Pair;
+import bjc.utils.data.IPair;
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * Utilities for manipulating FunctionalLists that don't belong in the
@@ -20,7 +21,7 @@ public class ListUtils {
 	private static final int MAX_NTRIESPART = 50;
 
 	private static final class TokenDeaffixer
-			implements BiFunction<String, String, FunctionalList<String>> {
+			implements BiFunction<String, String, IFunctionalList<String>> {
 		private String token;
 
 		public TokenDeaffixer(String tok) {
@@ -28,7 +29,7 @@ public class ListUtils {
 		}
 
 		@Override
-		public FunctionalList<String> apply(String operatorName,
+		public IFunctionalList<String> apply(String operatorName,
 				String operatorRegex) {
 			if (operatorName == null) {
 				throw new NullPointerException(
@@ -53,7 +54,7 @@ public class ListUtils {
 	}
 
 	private static final class TokenSplitter
-			implements BiFunction<String, String, FunctionalList<String>> {
+			implements BiFunction<String, String, IFunctionalList<String>> {
 		private String tokenToSplit;
 
 		public TokenSplitter(String tok) {
@@ -61,7 +62,7 @@ public class ListUtils {
 		}
 
 		@Override
-		public FunctionalList<String> apply(String operatorName,
+		public IFunctionalList<String> apply(String operatorName,
 				String operatorRegex) {
 			if (operatorName == null) {
 				throw new NullPointerException(
@@ -77,10 +78,10 @@ public class ListUtils {
 					return new FunctionalList<>(tokenToSplit);
 				}
 
-				FunctionalList<String> splitTokens = new FunctionalList<>(
+				IFunctionalList<String> splitTokens = new FunctionalList<>(
 						tokenToSplit.split(operatorRegex));
 
-				FunctionalList<String> result = new FunctionalList<>();
+				IFunctionalList<String> result = new FunctionalList<>();
 
 				int tokenExpansionSize = splitTokens.getSize();
 
@@ -112,17 +113,17 @@ public class ListUtils {
 	 */
 	private static final class GroupPartIteration<E>
 			implements Consumer<E> {
-		private FunctionalList<FunctionalList<E>>	returnedList;
-		private GenHolder<FunctionalList<E>>		currentPartition;
-		private FunctionalList<E>					rejectedItems;
+		private IFunctionalList<IFunctionalList<E>>	returnedList;
+		private GenHolder<IFunctionalList<E>>		currentPartition;
+		private IFunctionalList<E>					rejectedItems;
 		private GenHolder<Integer>					numberInCurrentPartition;
 		private int									numberPerPartition;
 		private Function<E, Integer>				elementCounter;
 
 		public GroupPartIteration(
-				FunctionalList<FunctionalList<E>> returned,
-				GenHolder<FunctionalList<E>> currPart,
-				FunctionalList<E> rejects,
+				IFunctionalList<IFunctionalList<E>> returned,
+				GenHolder<IFunctionalList<E>> currPart,
+				IFunctionalList<E> rejects,
 				GenHolder<Integer> numInCurrPart, int nPerPart,
 				Function<E, Integer> eleCount) {
 			this.returnedList = returned;
@@ -174,8 +175,8 @@ public class ListUtils {
 	 *            The number of elements to put in each partition
 	 * @return A list partitioned according to the above rules
 	 */
-	public static <E> FunctionalList<FunctionalList<E>> groupPartition(
-			FunctionalList<E> input, Function<E, Integer> elementCounter,
+	public static <E> IFunctionalList<IFunctionalList<E>> groupPartition(
+			IFunctionalList<E> input, Function<E, Integer> elementCounter,
 			int numberPerPartition) {
 		if (input == null) {
 			throw new NullPointerException("Input list must not be null");
@@ -192,17 +193,17 @@ public class ListUtils {
 		/*
 		 * List that holds our results
 		 */
-		FunctionalList<FunctionalList<E>> returnedList = new FunctionalList<>();
+		IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>();
 
 		/*
 		 * List that holds current partition
 		 */
-		GenHolder<FunctionalList<E>> currentPartition = new GenHolder<>(
+		GenHolder<IFunctionalList<E>> currentPartition = new GenHolder<>(
 				new FunctionalList<>());
 		/*
 		 * List that holds elements rejected during current pass
 		 */
-		FunctionalList<E> rejectedElements = new FunctionalList<>();
+		IFunctionalList<E> rejectedElements = new FunctionalList<>();
 
 		/*
 		 * The effective number of elements in the current partitition
@@ -251,9 +252,9 @@ public class ListUtils {
 	 * @return A list of tokens split on all the operators
 	 * 
 	 */
-	public static FunctionalList<String> splitTokens(
-			FunctionalList<String> input,
-			Deque<Pair<String, String>> operators) {
+	public static IFunctionalList<String> splitTokens(
+			IFunctionalList<String> input,
+			Deque<IPair<String, String>> operators) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
 		} else if (operators == null) {
@@ -261,7 +262,7 @@ public class ListUtils {
 					"Set of operators must not be null");
 		}
 
-		GenHolder<FunctionalList<String>> returnedList = new GenHolder<>(
+		GenHolder<IFunctionalList<String>> returnedList = new GenHolder<>(
 				input);
 
 		operators.forEach((operator) -> returnedList
@@ -282,9 +283,9 @@ public class ListUtils {
 	 * @return The tokens that have been deaffixed
 	 * 
 	 */
-	public static FunctionalList<String> deAffixTokens(
-			FunctionalList<String> input,
-			Deque<Pair<String, String>> operators) {
+	public static IFunctionalList<String> deAffixTokens(
+			IFunctionalList<String> input,
+			Deque<IPair<String, String>> operators) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
 		} else if (operators == null) {
@@ -292,7 +293,7 @@ public class ListUtils {
 					"Set of operators must not be null");
 		}
 
-		GenHolder<FunctionalList<String>> returnedList = new GenHolder<>(
+		GenHolder<IFunctionalList<String>> returnedList = new GenHolder<>(
 				input);
 
 		operators.forEach((operator) -> returnedList
@@ -311,7 +312,7 @@ public class ListUtils {
 	 *            The list of tokens to collapse
 	 * @return The collapsed string of tokens
 	 */
-	public static String collapseTokens(FunctionalList<String> input) {
+	public static String collapseTokens(IFunctionalList<String> input) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
 		}
@@ -329,7 +330,7 @@ public class ListUtils {
 	 *            The seperator to use for seperating tokens
 	 * @return The collapsed string of tokens
 	 */
-	public static String collapseTokens(FunctionalList<String> input,
+	public static String collapseTokens(IFunctionalList<String> input,
 			String seperator) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java b/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
index 4f194f3..349d9fa 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/RandomGrammar.java
@@ -1,8 +1,7 @@
 package bjc.utils.gen;
 
-import java.util.HashMap;
-
-import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * A weighted grammar where all the rules have a equal chance of occuring.
@@ -18,7 +17,7 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 	 * Create a new random grammar.
 	 */
 	public RandomGrammar() {
-		rules = new HashMap<>();
+		rules = new FunctionalMap<>();
 	}
 
 	/**
@@ -30,8 +29,8 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 	 *            The cases to add for this rule.
 	 */
 	@SafeVarargs
-	public final void addCases(E rule, FunctionalList<E>... cases) {
-		for (FunctionalList<E> currentCase : cases) {
+	public final void addCases(E rule, IFunctionalList<E>... cases) {
+		for (IFunctionalList<E> currentCase : cases) {
 			super.addCase(rule, 1, currentCase);
 		}
 	}
@@ -45,10 +44,10 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 	 *            The cases to add for this rule.
 	 */
 	@SafeVarargs
-	public final void makeRule(E rule, FunctionalList<E>... cases) {
+	public final void makeRule(E rule, IFunctionalList<E>... cases) {
 		super.addRule(rule);
 
-		for (FunctionalList<E> currentCase : cases) {
+		for (IFunctionalList<E> currentCase : cases) {
 			super.addCase(rule, 1, currentCase);
 		}
 	}
@@ -61,7 +60,8 @@ public class RandomGrammar<E> extends WeightedGrammar<E> {
 	 * @param cases
 	 *            The cases to add for this rule.
 	 */
-	public void makeRule(E rule, FunctionalList<FunctionalList<E>> cases) {
+	public void makeRule(E rule,
+			IFunctionalList<IFunctionalList<E>> cases) {
 		if (cases == null) {
 			throw new NullPointerException("Cases must not be null");
 		}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
index 5d61201..37f31b0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedGrammar.java
@@ -1,13 +1,14 @@
 package bjc.utils.gen;
 
-import java.util.Hashtable;
-import java.util.Map;
 import java.util.Random;
-import java.util.Set;
 import java.util.function.Function;
 
+import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 
 /**
  * A random grammar, where certain rules will come up more often than
@@ -22,29 +23,29 @@ public class WeightedGrammar<E> {
 	/**
 	 * The initial rule of the grammar
 	 */
-	protected String									initialRule;
+	protected String												initialRule;
 
 	/**
 	 * The rules currently in this grammar
 	 */
-	protected Map<E, WeightedRandom<FunctionalList<E>>>	rules;
+	protected IFunctionalMap<E, WeightedRandom<IFunctionalList<E>>>	rules;
 
 	/**
 	 * The random number generator used for random numbers
 	 */
-	private Random										rng;
+	private Random													rng;
 
 	/**
 	 * All of the subgrammars of this grammar
 	 */
-	protected Map<E, WeightedGrammar<E>>				subgrammars;
+	protected IFunctionalMap<E, WeightedGrammar<E>>					subgrammars;
 
 	/**
 	 * Create a new weighted grammar.
 	 */
 	public WeightedGrammar() {
-		rules = new Hashtable<>();
-		subgrammars = new Hashtable<>();
+		rules = new FunctionalMap<>();
+		subgrammars = new FunctionalMap<>();
 	}
 
 	/**
@@ -76,7 +77,7 @@ public class WeightedGrammar<E> {
 	 *            The case being added.
 	 */
 	public void addCase(E ruleName, int probability,
-			FunctionalList<E> cse) {
+			IFunctionalList<E> cse) {
 		if (ruleName == null) {
 			throw new NullPointerException("Rule name must be not null");
 		} else if (cse == null) {
@@ -145,7 +146,7 @@ public class WeightedGrammar<E> {
 	 * @return Whether or not the rule was succesfully added.
 	 */
 	public boolean addRule(E name,
-			WeightedRandom<FunctionalList<E>> cases) {
+			WeightedRandom<IFunctionalList<E>> cases) {
 		if (name == null) {
 			throw new NullPointerException("Name must not be null");
 		} else if (cases == null) {
@@ -193,15 +194,15 @@ public class WeightedGrammar<E> {
 	 *            The rule to test.
 	 * @return A set of sentances generated by the specified rule.
 	 */
-	public FunctionalList<FunctionalList<E>> generateDebugValues(
+	public IFunctionalList<IFunctionalList<E>> generateDebugValues(
 			E ruleName) {
 		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
 		}
 
-		FunctionalList<FunctionalList<E>> returnedList = new FunctionalList<>();
+		IFunctionalList<IFunctionalList<E>> returnedList = new FunctionalList<>();
 
-		WeightedRandom<FunctionalList<E>> ruleGenerator = rules
+		WeightedRandom<IFunctionalList<E>> ruleGenerator = rules
 				.get(ruleName);
 
 		for (int i = 0; i < 10; i++) {
@@ -226,7 +227,7 @@ public class WeightedGrammar<E> {
 	 * @return A randomly generated sentance from the specified initial
 	 *         rule.
 	 */
-	public <T> FunctionalList<T> generateGenericValues(E initRule,
+	public <T> IFunctionalList<T> generateGenericValues(E initRule,
 			Function<E, T> tokenTransformer, T spacer) {
 		if (initRule == null) {
 			throw new NullPointerException(
@@ -237,7 +238,7 @@ public class WeightedGrammar<E> {
 			throw new NullPointerException("Spacer must not be null");
 		}
 
-		FunctionalList<T> returnedList = new FunctionalList<>();
+		IFunctionalList<T> returnedList = new FunctionalList<>();
 
 		if (subgrammars.containsKey(initRule)) {
 			subgrammars.get(initRule).generateGenericValues(initRule,
@@ -280,7 +281,7 @@ public class WeightedGrammar<E> {
 	 * @return A list of random grammar elements generated by the specified
 	 *         rule.
 	 */
-	public FunctionalList<E> generateListValues(E initRule, E spacer) {
+	public IFunctionalList<E> generateListValues(E initRule, E spacer) {
 		return generateGenericValues(initRule, strang -> strang, spacer);
 	}
 
@@ -342,16 +343,23 @@ public class WeightedGrammar<E> {
 					"Number of times to prefix must be positive.");
 		}
 
-		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
+		WeightedRandom<IFunctionalList<E>> rule = rules.get(ruleName);
 
-		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults = new FunctionalList<>();
+		IFunctionalList<IPair<Integer, IFunctionalList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((pair) -> {
-			FunctionalList<FunctionalList<E>> newRule = new FunctionalList<>();
+			IFunctionalList<IFunctionalList<E>> newRule = new FunctionalList<>();
 
 			for (int i = 1; i <= numberOfTimes; i++) {
-				FunctionalList<E> newCase = pair
-						.merge((left, right) -> right.clone());
+				IFunctionalList<E> newCase = pair.merge((left, right) -> {
+					IFunctionalList<E> returnVal = new FunctionalList<>();
+
+					for (E val : right.toIterable()) {
+						returnVal.add(val);
+					}
+
+					return returnVal;
+				});
 
 				for (int j = 1; j <= i; j++) {
 					newCase.prepend(prefixToken);
@@ -392,13 +400,21 @@ public class WeightedGrammar<E> {
 					"Prefix token must not be null");
 		}
 
-		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
+		WeightedRandom<IFunctionalList<E>> rule = rules.get(ruleName);
 
-		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults = new FunctionalList<>();
+		IFunctionalList<IPair<Integer, IFunctionalList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((pair) -> {
-			FunctionalList<E> newCase = pair
-					.merge((left, right) -> right.clone());
+			IFunctionalList<E> newCase = pair.merge((left, right) -> {
+				IFunctionalList<E> returnVal = new FunctionalList<>();
+
+				for (E val : right.toIterable()) {
+					returnVal.add(val);
+				}
+
+				return returnVal;
+			});
+
 			newCase.prepend(prefixToken);
 
 			newResults.add(new Pair<>(pair.merge((left, right) -> left)
@@ -443,7 +459,7 @@ public class WeightedGrammar<E> {
 	 * @return The number of rules in this grammar
 	 */
 	public int getRuleCount() {
-		return rules.size();
+		return rules.getSize();
 	}
 
 	/**
@@ -451,8 +467,8 @@ public class WeightedGrammar<E> {
 	 * 
 	 * @return The set of all rule names in this grammar
 	 */
-	public Set<E> getRuleNames() {
-		return rules.keySet();
+	public IFunctionalList<E> getRuleNames() {
+		return rules.keyList();
 	}
 
 	/**
@@ -484,13 +500,20 @@ public class WeightedGrammar<E> {
 					"Prefix token must not be null");
 		}
 
-		WeightedRandom<FunctionalList<E>> rule = rules.get(ruleName);
+		WeightedRandom<IFunctionalList<E>> rule = rules.get(ruleName);
 
-		FunctionalList<Pair<Integer, FunctionalList<E>>> newResults = new FunctionalList<>();
+		IFunctionalList<IPair<Integer, IFunctionalList<E>>> newResults = new FunctionalList<>();
 
 		rule.getValues().forEach((par) -> {
-			FunctionalList<E> newCase = par
-					.merge((left, right) -> right.clone());
+			IFunctionalList<E> newCase = par.merge((left, right) -> {
+				IFunctionalList<E> returnVal = new FunctionalList<>();
+
+				for (E val : right.toIterable()) {
+					returnVal.add(val);
+				}
+
+				return returnVal;
+			});
 			newCase.add(suffixToken);
 
 			newResults.add(new Pair<>(par.merge((left, right) -> left)
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedRandom.java b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedRandom.java
index 5157ee2..10da34e 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedRandom.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gen/WeightedRandom.java
@@ -2,9 +2,10 @@ package bjc.utils.gen;
 
 import java.util.Random;
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.data.GenHolder;
 import bjc.utils.data.IHolder;
-import bjc.utils.data.Pair;
+import bjc.utils.data.IPair;
 
 /**
  * Represents a random number generator where certain results are weighted
@@ -19,12 +20,12 @@ public class WeightedRandom<E> {
 	/**
 	 * The list of probabilities for each result
 	 */
-	private FunctionalList<Integer>	probabilities;
+	private IFunctionalList<Integer>	probabilities;
 
 	/**
 	 * The list of possible results to pick from
 	 */
-	private FunctionalList<E>		results;
+	private IFunctionalList<E>		results;
 
 	/**
 	 * The source for any needed random numbers
@@ -101,7 +102,7 @@ public class WeightedRandom<E> {
 	 * 
 	 * @return A list of all the values that can be generated
 	 */
-	public FunctionalList<E> getResults() {
+	public IFunctionalList<E> getResults() {
 		return results;
 	}
 
@@ -111,7 +112,7 @@ public class WeightedRandom<E> {
 	 * 
 	 * @return A list of pairs of values and value probabilities
 	 */
-	public FunctionalList<Pair<Integer, E>> getValues() {
+	public IFunctionalList<IPair<Integer, E>> getValues() {
 		return probabilities.pairWith(results);
 	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
index 247ee31..a6e8eef 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/graph/AdjacencyMap.java
@@ -3,16 +3,15 @@ package bjc.utils.graph;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintStream;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.InputMismatchException;
-import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Scanner;
-import java.util.Set;
 import java.util.stream.IntStream;
 
 import bjc.utils.data.GenHolder;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 
 /**
  * An adjacency map representing a graph
@@ -65,7 +64,7 @@ public class AdjacencyMap<T> {
 						"The number of vertices must be greater than 0");
 			}
 
-			Set<Integer> vertices = new HashSet<>();
+			IFunctionalList<Integer> vertices = new FunctionalList<>();
 
 			IntStream.range(0, numVertices)
 					.forEach(element -> vertices.add(element));
@@ -91,8 +90,9 @@ public class AdjacencyMap<T> {
 					try {
 						columnWeight = Integer.parseInt(part);
 					} catch (NumberFormatException nfex) {
-						InputMismatchException imex = new InputMismatchException(
-								"" + part + " is not a valid weight.");
+						InputMismatchException imex =
+								new InputMismatchException("" + part
+										+ " is not a valid weight.");
 
 						imex.initCause(nfex);
 
@@ -119,7 +119,8 @@ public class AdjacencyMap<T> {
 	/**
 	 * The backing storage of the map
 	 */
-	private Map<T, Map<T, Integer>> adjacencyMap = new HashMap<>();
+	private IFunctionalMap<T, IFunctionalMap<T, Integer>> adjacencyMap =
+			new FunctionalMap<>();
 
 	/**
 	 * Create a new map from a set of vertices
@@ -127,13 +128,13 @@ public class AdjacencyMap<T> {
 	 * @param vertices
 	 *            The set of vertices to create a map from
 	 */
-	public AdjacencyMap(Set<T> vertices) {
+	public AdjacencyMap(IFunctionalList<T> vertices) {
 		if (vertices == null) {
 			throw new NullPointerException("Vertices must not be null");
 		}
 
 		vertices.forEach(vertex -> {
-			Map<T, Integer> vertexRow = new HashMap<>();
+			IFunctionalMap<T, Integer> vertexRow = new FunctionalMap<>();
 
 			vertices.forEach(
 					targetVertex -> vertexRow.put(targetVertex, 0));
@@ -150,16 +151,11 @@ public class AdjacencyMap<T> {
 	public boolean isDirected() {
 		GenHolder<Boolean> result = new GenHolder<>(true);
 
-		adjacencyMap.entrySet().forEach(mapEntry -> {
-			Set<Entry<T, Integer>> entryVertices = mapEntry.getValue()
-					.entrySet();
+		adjacencyMap.forEach((key, value) -> {
+			value.forEach((targetKey, targetValue) -> {
+				int inverseValue = adjacencyMap.get(targetKey).get(key);
 
-			entryVertices.forEach(targetVertex -> {
-				int leftValue = targetVertex.getValue();
-				int rightValue = adjacencyMap.get(targetVertex.getKey())
-						.get(mapEntry.getKey());
-
-				if (leftValue != rightValue) {
+				if (targetValue != inverseValue) {
 					result.transform((bool) -> false);
 				}
 			});
@@ -206,11 +202,11 @@ public class AdjacencyMap<T> {
 	public Graph<T> toGraph() {
 		Graph<T> returnedGraph = new Graph<>();
 
-		adjacencyMap.entrySet().forEach(sourceVertex -> sourceVertex
-				.getValue().entrySet()
-				.forEach(targetVertex -> returnedGraph.addEdge(
-						sourceVertex.getKey(), targetVertex.getKey(),
-						targetVertex.getValue())));
+		adjacencyMap.forEach((key, value) -> {
+			value.forEach((targetKey, targetValue) -> {
+				returnedGraph.addEdge(key, targetKey, targetValue, true);
+			});
+		});
 
 		return returnedGraph;
 	}
@@ -229,10 +225,11 @@ public class AdjacencyMap<T> {
 
 		PrintStream outputPrinter = new PrintStream(outputSink);
 
-		adjacencyMap.entrySet().forEach(sourceVertex -> {
-			sourceVertex.getValue().entrySet()
-					.forEach(targetVertex -> outputPrinter.printf("%d ",
-							targetVertex.getValue()));
+		adjacencyMap.forEach((key, value) -> {
+			value.forEach((targetKey, targetValue) -> {
+				outputPrinter.printf("%d", targetValue);
+			});
+
 			outputPrinter.println();
 		});
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/graph/Graph.java b/BJC-Utils2/src/main/java/bjc/utils/graph/Graph.java
index f6bfc85..8041604 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/graph/Graph.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/graph/Graph.java
@@ -1,11 +1,8 @@
 package bjc.utils.graph;
 
 import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.PriorityQueue;
 import java.util.Queue;
@@ -15,6 +12,9 @@ import java.util.function.BiPredicate;
 
 import bjc.utils.data.GenHolder;
 import bjc.utils.data.IHolder;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 
 /**
  * A directed weighted graph, where the vertices have some arbitrary label
@@ -29,13 +29,13 @@ public class Graph<T> {
 	/**
 	 * The backing representation of the graph
 	 */
-	private final Map<T, Map<T, Integer>> backingGraph;
+	private final IFunctionalMap<T, IFunctionalMap<T, Integer>> backingGraph;
 
 	/**
 	 * Create a new graph
 	 */
 	public Graph() {
-		backingGraph = new HashMap<>();
+		backingGraph = new FunctionalMap<>();
 	}
 
 	/**
@@ -47,8 +47,11 @@ public class Graph<T> {
 	 *            The target vertex for this edge
 	 * @param distance
 	 *            The distance from the source vertex to the target vertex
+	 * @param directed
+	 *            Whether or not
 	 */
-	public void addEdge(T sourceVertex, T targetVertex, int distance) {
+	public void addEdge(T sourceVertex, T targetVertex, int distance,
+			boolean directed) {
 		// Can't add edges with a null source or target
 		if (sourceVertex == null) {
 			throw new NullPointerException(
@@ -60,17 +63,22 @@ public class Graph<T> {
 
 		// Initialize adjacency list for vertices if necessary
 		if (!backingGraph.containsKey(sourceVertex)) {
-			backingGraph.put(sourceVertex, new HashMap<T, Integer>());
-		}
-		if (!backingGraph.containsKey(targetVertex)) {
-			backingGraph.put(targetVertex, new HashMap<T, Integer>());
+			backingGraph.put(sourceVertex,
+					new FunctionalMap<T, Integer>());
 		}
 
 		// Add the edge to the graph
 		backingGraph.get(sourceVertex).put(targetVertex, distance);
 
-		// Uncomment this to make the graph undirected
-		// graph.get(target).put(source, distance);
+		// Handle possible directed edges
+		if (!directed) {
+			if (!backingGraph.containsKey(targetVertex)) {
+				backingGraph.put(targetVertex,
+						new FunctionalMap<T, Integer>());
+			}
+
+			backingGraph.get(targetVertex).put(sourceVertex, distance);
+		}
 	}
 
 	/**
@@ -107,7 +115,7 @@ public class Graph<T> {
 	 *            The vertex to use as a source
 	 * @return All of the edges with the specified vertex as a source
 	 */
-	public Map<T, Integer> getEdges(T source) {
+	public IFunctionalMap<T, Integer> getEdges(T source) {
 		// Can't find edges for a null source
 		if (source == null) {
 			throw new NullPointerException("The source cannot be null.");
@@ -116,7 +124,7 @@ public class Graph<T> {
 					"Vertex " + source + " is not in graph");
 		}
 
-		return Collections.unmodifiableMap(backingGraph.get(source));
+		return backingGraph.get(source);
 	}
 
 	/**
@@ -125,7 +133,7 @@ public class Graph<T> {
 	 * @return The initial vertex of the graph
 	 */
 	public T getInitial() {
-		return backingGraph.keySet().iterator().next();
+		return backingGraph.keyList().first();
 	}
 
 	/**
@@ -195,7 +203,7 @@ public class Graph<T> {
 	 * @return A count of the vertices in this graph
 	 */
 	public int getVertexCount() {
-		return backingGraph.size();
+		return backingGraph.getSize();
 	}
 
 	/**
@@ -203,8 +211,8 @@ public class Graph<T> {
 	 * 
 	 * @return A unmodifiable set of all the vertices in the graph.
 	 */
-	public Set<T> getVertices() {
-		return Collections.unmodifiableSet(backingGraph.keySet());
+	public IFunctionalList<T> getVertices() {
+		return backingGraph.keyList();
 	}
 
 	/**
@@ -249,13 +257,13 @@ public class Graph<T> {
 	 */
 	public AdjacencyMap<T> toAdjacencyMap() {
 		AdjacencyMap<T> adjacencyMap =
-				new AdjacencyMap<>(backingGraph.keySet());
+				new AdjacencyMap<>(backingGraph.keyList());
 
-		backingGraph.entrySet().forEach(sourceVertex -> sourceVertex
-				.getValue()
-				.forEach((targetVertex, vertexWeight) -> adjacencyMap
-						.setWeight(sourceVertex.getKey(), targetVertex,
-								vertexWeight)));
+		backingGraph.forEach((key, value) -> {
+			value.forEach((targetKey, targetValue) -> {
+				adjacencyMap.setWeight(key, targetKey, targetValue);
+			});
+		});
 
 		return adjacencyMap;
 	}
@@ -274,7 +282,7 @@ public class Graph<T> {
 		Graph<E> g = new Graph<>();
 
 		edges.forEach(edge -> g.addEdge(edge.getSource(), edge.getTarget(),
-				edge.getDistance()));
+				edge.getDistance(), true));
 
 		return g;
 	}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/ExtensionFileFilter.java b/BJC-Utils2/src/main/java/bjc/utils/gui/ExtensionFileFilter.java
index e563530..766b241 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gui/ExtensionFileFilter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gui/ExtensionFileFilter.java
@@ -2,10 +2,10 @@ package bjc.utils.gui;
 
 import java.io.File;
 import javax.swing.filechooser.FileFilter;
-import java.util.ArrayList;
 import java.util.List;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * A file filter based on extensions.
@@ -19,7 +19,7 @@ public class ExtensionFileFilter extends FileFilter {
 	/**
 	 * The list holding all filtered extensions
 	 */
-	private FunctionalList<String> extensions;
+	private IFunctionalList<String> extensions;
 
 	/**
 	 * Create a new filter only showing files with the specified
@@ -40,11 +40,7 @@ public class ExtensionFileFilter extends FileFilter {
 	 *            The extensions to show in this filter.
 	 */
 	public ExtensionFileFilter(String... exts) {
-		extensions = new FunctionalList<>(new ArrayList<>(exts.length));
-
-		for (String extension : exts) {
-			extensions.add(extension);
-		}
+		extensions = new FunctionalList<>(exts);
 	}
 
 	@Override
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java b/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java
index 4bbe6e7..26a5a78 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gui/ListParameterPanel.java
@@ -9,7 +9,7 @@ import javax.swing.JList;
 import javax.swing.JPanel;
 import javax.swing.ListSelectionModel;
 
-import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 import bjc.utils.gui.layout.HLayout;
 import bjc.utils.gui.layout.VLayout;
 
@@ -54,7 +54,7 @@ public class ListParameterPanel<E> extends JPanel {
 	 */
 	public ListParameterPanel(Supplier<E> addAction,
 			Consumer<E> editAction, Consumer<E> removeAction,
-			FunctionalList<E> defaultValues) {
+			IFunctionalList<E> defaultValues) {
 		setLayout(new VLayout(2));
 
 		JList<E> list;
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/awt/ExtensionFileFilter.java b/BJC-Utils2/src/main/java/bjc/utils/gui/awt/ExtensionFileFilter.java
index 7e2c2d2..230b768 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gui/awt/ExtensionFileFilter.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gui/awt/ExtensionFileFilter.java
@@ -2,10 +2,10 @@ package bjc.utils.gui.awt;
 
 import java.io.File;
 import java.io.FilenameFilter;
-import java.util.ArrayList;
 import java.util.List;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * Filter a set of filenames by extension.
@@ -19,7 +19,7 @@ public class ExtensionFileFilter implements FilenameFilter {
 	/**
 	 * The list of extensions to filter
 	 */
-	private FunctionalList<String> extensions;
+	private IFunctionalList<String> extensions;
 
 	/**
 	 * Create a new filter only showing files with the specified
@@ -44,11 +44,7 @@ public class ExtensionFileFilter implements FilenameFilter {
 	 *            The extensions to show in this filter.
 	 */
 	public ExtensionFileFilter(String... exts) {
-		extensions = new FunctionalList<>(new ArrayList<>(exts.length));
-
-		for (String extension : exts) {
-			extensions.add(extension);
-		}
+		extensions = new FunctionalList<>(exts);
 	}
 
 	@Override
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
index 90961d5..88b4862 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/AST.java
@@ -183,11 +183,14 @@ public class AST<T> {
 	/**
 	 * Expand the nodes in an AST
 	 * 
+	 * This is actually equivalent to converting the tree into an ordered
+	 * list, doing a flatMap, and then reconstructing the tree
+	 * 
 	 * @param expander
 	 *            The function to use for expanding nodes
 	 * @return The expanded AST
 	 */
-	public AST<T> expand(Function<T, AST<T>> expander) {
+	public AST<T> flatMapTree(Function<T, AST<T>> expander) {
 		if (expander == null) {
 			throw new NullPointerException("Expander must not be null");
 		}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
index b6162e5..999503c 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedConfigReader.java
@@ -8,6 +8,7 @@ import java.util.Scanner;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
+import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 import bjc.utils.exceptions.UnknownPragmaException;
 import bjc.utils.funcdata.FunctionalStringTokenizer;
@@ -20,9 +21,10 @@ import bjc.utils.funcdata.FunctionalStringTokenizer;
  *
  * @param <E>
  *            The type of the state object to use
+ * 
  */
 public class RuleBasedConfigReader<E> {
-	private BiConsumer<FunctionalStringTokenizer, Pair<String, E>>	startRule;
+	private BiConsumer<FunctionalStringTokenizer, IPair<String, E>>	startRule;
 	private BiConsumer<FunctionalStringTokenizer, E>				continueRule;
 	private Consumer<E>												endRule;
 
@@ -39,7 +41,7 @@ public class RuleBasedConfigReader<E> {
 	 *            The action to fire when ending a rule
 	 */
 	public RuleBasedConfigReader(
-			BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule,
+			BiConsumer<FunctionalStringTokenizer, IPair<String, E>> startRule,
 			BiConsumer<FunctionalStringTokenizer, E> continueRule,
 			Consumer<E> endRule) {
 		this.startRule = startRule;
@@ -90,20 +92,26 @@ public class RuleBasedConfigReader<E> {
 
 			state = initialState;
 			boolean ruleOpen = false;
+
 			while (inputSource.hasNextLine()) {
 				String line = inputSource.nextLine();
 
-				if (line.equals("")) {
+				if (line.startsWith("#") || line.startsWith("//")) {
+					// It's a comment
+					continue;
+				} else if (line.equals("")) {
 					if (ruleOpen == false) {
 						// Ignore blank line without an open rule
-					}
-
-					if (endRule == null) {
-						// Nothing happens on rule end
 					} else {
-						endRule.accept(state);
-					}
+						if (endRule == null) {
+							// Nothing happens on rule end
+							ruleOpen = false;
+						} else {
+							endRule.accept(state);
+						}
 
+						ruleOpen = false;
+					}
 					continue;
 				} else if (line.startsWith("\t")) {
 					if (ruleOpen == false) {
@@ -125,9 +133,7 @@ public class RuleBasedConfigReader<E> {
 
 					String nextToken = tokenizer.nextToken();
 
-					if (nextToken.equals("#") || nextToken.equals("//")) {
-						// Do nothing, this is a comment
-					} else if (nextToken.equals("pragma")) {
+					if (nextToken.equals("pragma")) {
 						String token = tokenizer.nextToken();
 
 						pragmas.getOrDefault(token, (tokenzer, stat) -> {
@@ -181,7 +187,7 @@ public class RuleBasedConfigReader<E> {
 	 *            The action to execute on starting of a rule
 	 */
 	public void setStartRule(
-			BiConsumer<FunctionalStringTokenizer, Pair<String, E>> startRule) {
+			BiConsumer<FunctionalStringTokenizer, IPair<String, E>> startRule) {
 		if (startRule == null) {
 			throw new NullPointerException(
 					"Action on rule start must be non-null");
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
index 1e5d487..a60cb01 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
@@ -1,13 +1,14 @@
 package bjc.utils.parserutils;
 
 import java.util.Deque;
-import java.util.HashMap;
 import java.util.LinkedList;
-import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcutils.StringUtils;
 
 /**
@@ -61,11 +62,11 @@ public class ShuntingYard<E> {
 	}
 
 	private final class TokenShunter implements Consumer<String> {
-		private FunctionalList<E>	output;
+		private IFunctionalList<E>	output;
 		private Deque<String>		stack;
 		private Function<String, E>	transform;
 
-		public TokenShunter(FunctionalList<E> outpt, Deque<String> stack,
+		public TokenShunter(IFunctionalList<E> outpt, Deque<String> stack,
 				Function<String, E> transform) {
 			this.output = outpt;
 			this.stack = stack;
@@ -115,13 +116,13 @@ public class ShuntingYard<E> {
 	/**
 	 * Holds all the shuntable operations
 	 */
-	private Map<String, IPrecedent> operators;
+	private IFunctionalMap<String, IPrecedent> operators;
 
 	/**
 	 * Create a new shunting yard with a default set of operators
 	 */
 	public ShuntingYard() {
-		operators = new HashMap<>();
+		operators = new FunctionalMap<>();
 
 		if (shouldConfigureBasicOperators) {
 			operators.put("+", Operator.ADD);
@@ -175,7 +176,7 @@ public class ShuntingYard<E> {
 	 *            The function to use to transform strings to tokens
 	 * @return A list of tokens in postfix notation
 	 */
-	public FunctionalList<E> postfix(FunctionalList<String> input,
+	public IFunctionalList<E> postfix(IFunctionalList<String> input,
 			Function<String, E> tokenTransformer) {
 		if (input == null) {
 			throw new NullPointerException("Input must not be null");
@@ -183,7 +184,7 @@ public class ShuntingYard<E> {
 			throw new NullPointerException("Transformer must not be null");
 		}
 
-		FunctionalList<E> output = new FunctionalList<>();
+		IFunctionalList<E> output = new FunctionalList<>();
 
 		Deque<String> stack = new LinkedList<>();
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
index 6fedf87..46e4da4 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
@@ -9,7 +9,7 @@ import java.util.function.Predicate;
 import bjc.utils.data.GenHolder;
 import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
-import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
 
 /**
  * Creates a parse tree from a postfix expression
@@ -119,7 +119,7 @@ public class TreeConstructor {
 	 *            operator
 	 * @return A AST from the expression
 	 */
-	public static <T> AST<T> constructTree(FunctionalList<T> tokens,
+	public static <T> AST<T> constructTree(IFunctionalList<T> tokens,
 			Predicate<T> operatorPredicate) {
 		return constructTree(tokens, operatorPredicate, (op) -> false,
 				null);
@@ -149,7 +149,7 @@ public class TreeConstructor {
 	 *         interface. Maybe there's a better way to express how that
 	 *         works
 	 */
-	public static <T> AST<T> constructTree(FunctionalList<T> tokens,
+	public static <T> AST<T> constructTree(IFunctionalList<T> tokens,
 			Predicate<T> operatorPredicate, Predicate<T> isSpecialOperator,
 			Function<Deque<AST<T>>, AST<T>> handleSpecialOperator) {
 		if (tokens == null) {