General changes

29 files changed, 989 insertions, 441 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommandMode.java b/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommandMode.java
index a9c9054..0007616 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommandMode.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/cli/GenericCommandMode.java
@@ -82,11 +82,11 @@ public class GenericCommandMode implements ICommandMode {
 		} else {
 			ICommand aliasedCommand;
 			if (defaultHandlers.containsKey(commandName)) {
-				aliasedCommand =
-						defaultHandlers.get(commandName).createAlias();
+				aliasedCommand = defaultHandlers.get(commandName)
+						.createAlias();
 			} else {
-				aliasedCommand =
-						commandHandlers.get(commandName).createAlias();
+				aliasedCommand = commandHandlers.get(commandName)
+						.createAlias();
 			}
 
 			commandHandlers.put(aliasName, aliasedCommand);
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 bc1b990..e05afc0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/components/FileComponentRepository.java
@@ -57,7 +57,7 @@ public class FileComponentRepository<E extends IDescribedComponent>
 	 *            The function to use to convert files to components
 	 */
 	public FileComponentRepository(File directory,
-			Function<File, E> componentReader) {
+			Function<File, ? extends E> componentReader) {
 		if (!directory.isDirectory()) {
 			throw new IllegalArgumentException("File " + directory
 					+ " is not a directory.\n"
@@ -123,7 +123,7 @@ public class FileComponentRepository<E extends IDescribedComponent>
 		return "Components read from directory " + sourceDirectory + ".";
 	}
 
-	private void loadComponent(Function<File, E> componentReader,
+	private void loadComponent(Function<File, ? extends E> componentReader,
 			Path pth) {
 		try {
 			E component = componentReader.apply(pth.toFile());
diff --git a/BJC-Utils2/src/main/java/bjc/utils/configuration/ConfigFile.java b/BJC-Utils2/src/main/java/bjc/utils/configuration/ConfigFile.java
deleted file mode 100644
index aa436ee..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/configuration/ConfigFile.java
+++ /dev/null
@@ -1,162 +0,0 @@
-package bjc.utils.configuration;
-
-import java.io.InputStream;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Scanner;
-
-import javax.lang.model.SourceVersion;
-
-/**
- * A config file with support for categories, comments and other thins
- * 
- * @author ben
- *
- */
-public class ConfigFile {
-	/**
-	 * A category in a configuration file
-	 * 
-	 * @author ben
-	 *
-	 */
-	public static class ConfigCategory {
-		private Map<String, ConfigCategory> children;
-
-		/**
-		 * Create a new config category
-		 */
-		public ConfigCategory() {
-			children = new HashMap<>();
-		}
-
-		/**
-		 * Add a child category to this category
-		 * 
-		 * @param childName
-		 *            The name of the child
-		 * @param child
-		 *            The child category
-		 */
-		public void addChild(String childName, ConfigCategory child) {
-			children.put(childName, child);
-		}
-	}
-
-	private static Map<String, ConfigCategory> topLevelCategories;
-
-	private static boolean isCommentMarker(String token) {
-		switch (token) {
-			case "#":
-			case "//":
-				return true;
-			default:
-				return false;
-		}
-	}
-
-	/**
-	 * Parse the values in a config file from a stream
-	 * 
-	 * @param source
-	 *            The stream to parse values from
-	 * @return A config file with values parsed from the stream
-	 */
-	public static ConfigFile parse(InputStream source) {
-		Scanner scn = new Scanner(source);
-
-		ConfigFile returnedFile = new ConfigFile();
-
-		while (scn.hasNextLine()) {
-			String currentLine = scn.nextLine();
-
-			// Ignore blank lines
-			if (currentLine.equals("")) {
-				continue;
-			}
-
-			String[] currentTokens = currentLine.split(" ");
-
-			// Ignore lines that start with a comment marker
-			if (isCommentMarker(currentTokens[0])) {
-				continue;
-			} else if (SourceVersion.isName(currentTokens[0])
-					&& currentTokens[1].equals("{")) {
-				topLevelCategories.put(currentTokens[0],
-						parseCategory(currentTokens[0], scn));
-			}
-		}
-
-		scn.close();
-
-		return returnedFile;
-	}
-
-	private static ConfigCategory parseCategory(
-			@SuppressWarnings("unused") String categoryName,
-			Scanner inputSource) {
-		ConfigCategory category = new ConfigCategory();
-
-		String currentLine = inputSource.nextLine();
-
-		String[] tokens = currentLine.split("\\s+ ");
-
-		// Parse contents of category
-		while (!tokens[0].equals("}")) {
-			// Ignore lines starting with comment marker
-			if (isCommentMarker(tokens[0])) {
-				continue;
-			}
-
-			int initialCommandToken = 0;
-
-			// Skip over blank tokens from lots of spacing
-			for (int i = 0; i < tokens.length; i++) {
-				String token = tokens[i];
-
-				if (token.equals("")) {
-					continue;
-				} else {
-					initialCommandToken = i;
-					break;
-				}
-			}
-
-			String[] relevantTokens = Arrays.copyOfRange(tokens,
-					initialCommandToken, tokens.length);
-
-			// Parse child subcategories
-			if (SourceVersion.isName(relevantTokens[0])
-					&& relevantTokens[1].equals("{")) {
-				parseCategory(relevantTokens[0], inputSource);
-			} else {
-				// Parse config fields
-				parseEntry(category, relevantTokens);
-			}
-			currentLine = inputSource.nextLine();
-
-			tokens = currentLine.split("\\s+ ");
-		}
-
-		return category;
-	}
-
-	private static void parseEntry(
-			@SuppressWarnings("unused") ConfigCategory category,
-			String[] entryParts) {
-		String entry = String.join("", entryParts);
-
-		String[] expParts = entry.split("=");
-
-		String[] expSpecifiers = expParts[0].split(":");
-
-		String expType = expSpecifiers[0];
-		@SuppressWarnings("unused")
-		String expName = expSpecifiers[1];
-
-		switch (expType) {
-
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/configuration/Configuration.java b/BJC-Utils2/src/main/java/bjc/utils/configuration/Configuration.java
deleted file mode 100644
index 7944c44..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/configuration/Configuration.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package bjc.utils.configuration;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation that marks a class as having a config file bound to it
- * 
- * For this annotation to be valid to apply to the class, the class must
- * meet two qualities
- * 
- * 1. Have a public no-args constructor
- * 
- * 2. Have one or more fields annoted with a {@link FieldMarker} annotation
- * 
- * @author ben
- *
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-@Documented
-public @interface Configuration {
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/configuration/Configurator.java b/BJC-Utils2/src/main/java/bjc/utils/configuration/Configurator.java
deleted file mode 100644
index e116dea..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/configuration/Configurator.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package bjc.utils.configuration;
-
-import java.io.InputStream;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-/**
- * Bind the values in a prepared class to a config file
- * 
- * @author ben
- *
- */
-public class Configurator {
-	/**
-	 * Bind the values in a config file to the values in a class,
-	 * substituting default values if none are appropriate
-	 * 
-	 * @param <E>
-	 *            The type of the object to bind
-	 * @param clasz
-	 *            The class of the object to bind
-	 * @param inputSource
-	 *            The source to get input from
-	 * @return A instance of the provided class, with values filled in from
-	 *         a config file
-	 */
-	public static <E> E readConfig(Class<E> clasz,
-			InputStream inputSource) {
-		try {
-			Constructor<E> noArgConstructor = clasz.getConstructor();
-
-			E backingStore = noArgConstructor.newInstance();
-
-			return backingStore;
-		} catch (NoSuchMethodException | SecurityException
-				| InstantiationException | IllegalAccessException
-				| IllegalArgumentException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-
-			return null;
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldMarker.java b/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldMarker.java
deleted file mode 100644
index 1d59fa3..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldMarker.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package bjc.utils.configuration;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotation to bind a field to a field in a config file
- * 
- * @author ben
- *
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Documented
-public @interface FieldMarker {
-	/**
-	 * The type of config field being represented
-	 * 
-	 * @return The type of config field being represented
-	 */
-	public FieldType value();
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldType.java b/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldType.java
deleted file mode 100644
index a1545e5..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/configuration/FieldType.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package bjc.utils.configuration;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Container interface for field type markers
- * 
- * There can't be a String field type, so for fields of a single string,
- * use FieldType itself
- * 
- * @author ben
- *
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.FIELD)
-@Documented
-public @interface FieldType {
-	/**
-	 * Marker to indicate a field as a single boolean flag
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Flag {
-		/**
-		 * The default value of the flag
-		 * 
-		 * @return The default value of the flag
-		 */
-		boolean value() default false;
-	}
-
-	/**
-	 * Marker to indicate a fields as an array of boolean flags
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Flags {
-		/**
-		 * The default value of the flags
-		 * 
-		 * @return The default value of the flags
-		 */
-		boolean[] value() default { false };
-	}
-
-	/**
-	 * Marker to indicate a field as a single floating point value
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Float {
-		/**
-		 * The default value of the number
-		 * 
-		 * @return The default value of the number
-		 */
-		double value() default 0.0;
-	}
-
-	/**
-	 * Marker to indicate a fields as an array of floating point values
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Floats {
-		/**
-		 * The default value of the numbers
-		 * 
-		 * @return The default value of the numbers
-		 */
-		double[] value() default { 0.0 };
-	}
-
-	/**
-	 * Marker to indicate a field as a single integral value
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Integer {
-		/**
-		 * The default value of the integer
-		 * 
-		 * @return The default value of the integer
-		 */
-		int value() default 0;
-	}
-
-	/**
-	 * Marker to indicate a fields as an array of integral values
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Integers {
-		/**
-		 * The default value of the integers
-		 * 
-		 * @return The default value of the integers
-		 */
-		int[] value() default { 0 };
-	}
-
-	/**
-	 * Marker to indicate a fields as an array of strings
-	 * 
-	 * @author Benjamin
-	 *
-	 */
-	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.FIELD)
-	public @interface Strings {
-		/**
-		 * The default value of each of the strings
-		 * 
-		 * @return The default value of each of the strings
-		 */
-		String[] value() default { "" };
-	}
-
-	/**
-	 * The default value of the string
-	 * 
-	 * @return The default value of the strings
-	 */
-	public String value() default "";
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java
index ce47eb9..9ab3c05 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazy.java
@@ -96,4 +96,12 @@ class BoundLazy<OldType, BoundContainedType>
 
 		return boundHolder.unwrap(unwrapper);
 	}
+
+	@Override
+	public <NewType> Function<BoundContainedType, IHolder<NewType>> lift(
+			Function<BoundContainedType, NewType> func) {
+		return (val) -> {
+			return new Lazy<>(func.apply(val));
+		};
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
index a49bb9a..1635e06 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundLazyPair.java
@@ -90,8 +90,8 @@ class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<NewLeft, NewRight, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<NewLeft, NewRight, MergedType> merger) {
 		if (!pairBound) {
 			boundPair = binder.apply(leftSupplier.get(),
 					rightSupplier.get());
@@ -110,4 +110,60 @@ class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight>
 
 		return "(un-materialized)";
 	}
+
+	@Override
+	public <NewLeftType> IPair<NewLeftType, NewRight>
+			mapLeft(Function<NewLeft, NewLeftType> mapper) {
+		Supplier<NewLeftType> leftSupp = () -> {
+			if (!pairBound) {
+				NewLeft leftVal = binder
+						.apply(leftSupplier.get(), rightSupplier.get())
+						.getLeft();
+
+				return mapper.apply(leftVal);
+			}
+
+			return mapper.apply(boundPair.getLeft());
+		};
+
+		Supplier<NewRight> rightSupp = () -> {
+			if (!pairBound) {
+				return binder
+						.apply(leftSupplier.get(), rightSupplier.get())
+						.getRight();
+			}
+
+			return boundPair.getRight();
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
+
+	@Override
+	public <NewRightType> IPair<NewLeft, NewRightType>
+			mapRight(Function<NewRight, NewRightType> mapper) {
+		Supplier<NewLeft> leftSupp = () -> {
+			if (!pairBound) {
+				return binder
+						.apply(leftSupplier.get(), rightSupplier.get())
+						.getLeft();
+			}
+
+			return boundPair.getLeft();
+		};
+
+		Supplier<NewRightType> rightSupp = () -> {
+			if (!pairBound) {
+				NewRight rightVal = binder
+						.apply(leftSupplier.get(), rightSupplier.get())
+						.getRight();
+
+				return mapper.apply(rightVal);
+			}
+
+			return mapper.apply(boundPair.getRight());
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/BoundListHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/BoundListHolder.java
new file mode 100644
index 0000000..fcb62f6
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/BoundListHolder.java
@@ -0,0 +1,61 @@
+package bjc.utils.data;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+import bjc.utils.funcdata.IFunctionalList;
+
+class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
+	private IFunctionalList<IHolder<ContainedType>> heldHolders;
+
+	public BoundListHolder(
+			IFunctionalList<IHolder<ContainedType>> toHold) {
+		heldHolders = toHold;
+	}
+
+	@Override
+	public <BoundType> IHolder<BoundType> bind(
+			Function<ContainedType, IHolder<BoundType>> binder) {
+		IFunctionalList<IHolder<BoundType>> boundHolders = heldHolders
+				.map((containedHolder) -> {
+					return containedHolder.bind(binder);
+				});
+
+		return new BoundListHolder<>(boundHolders);
+	}
+
+	@Override
+	public <MappedType> IHolder<MappedType> map(
+			Function<ContainedType, MappedType> mapper) {
+		IFunctionalList<IHolder<MappedType>> mappedHolders = heldHolders
+				.map((containedHolder) -> {
+					return containedHolder.map(mapper);
+				});
+
+		return new BoundListHolder<>(mappedHolders);
+	}
+
+	@Override
+	public IHolder<ContainedType> transform(
+			UnaryOperator<ContainedType> transformer) {
+		heldHolders.forEach((containedHolder) -> {
+			containedHolder.transform(transformer);
+		});
+
+		return this;
+	}
+
+	@Override
+	public <UnwrappedType> UnwrappedType unwrap(
+			Function<ContainedType, UnwrappedType> unwrapper) {
+		return heldHolders.randItem().unwrap(unwrapper);
+	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new ListHolder<>(func.apply(val));
+		};
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java
index 037dddf..9e26924 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/HalfBoundLazyPair.java
@@ -80,8 +80,8 @@ class HalfBoundLazyPair<OldType, NewLeft, NewRight>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<NewLeft, NewRight, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<NewLeft, NewRight, MergedType> merger) {
 		if (!pairBound) {
 			boundPair = binder.apply(oldSupplier.get());
 
@@ -90,4 +90,52 @@ class HalfBoundLazyPair<OldType, NewLeft, NewRight>
 
 		return boundPair.merge(merger);
 	}
+
+	@Override
+	public <NewLeftType> IPair<NewLeftType, NewRight>
+			mapLeft(Function<NewLeft, NewLeftType> mapper) {
+		Supplier<NewLeftType> leftSupp = () -> {
+			if (pairBound) {
+				return mapper.apply(boundPair.getLeft());
+			}
+
+			NewLeft leftVal = binder.apply(oldSupplier.get()).getLeft();
+
+			return mapper.apply(leftVal);
+		};
+
+		Supplier<NewRight> rightSupp = () -> {
+			if (pairBound) {
+				return boundPair.getRight();
+			}
+
+			return binder.apply(oldSupplier.get()).getRight();
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
+
+	@Override
+	public <NewRightType> IPair<NewLeft, NewRightType>
+			mapRight(Function<NewRight, NewRightType> mapper) {
+		Supplier<NewLeft> leftSupp = () -> {
+			if (pairBound) {
+				return boundPair.getLeft();
+			}
+
+			return binder.apply(oldSupplier.get()).getLeft();
+		};
+
+		Supplier<NewRightType> rightSupp = () -> {
+			if (pairBound) {
+				return mapper.apply(boundPair.getRight());
+			}
+
+			NewRight rightVal = binder.apply(oldSupplier.get()).getRight();
+
+			return mapper.apply(rightVal);
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java
index ecf3f14..58ae5db 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/IHolder.java
@@ -4,6 +4,9 @@ import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.theory.Functor;
+
 /**
  * A holder of a single value.
  * 
@@ -12,7 +15,7 @@ import java.util.function.UnaryOperator;
  * @param <ContainedType>
  *            The type of value held
  */
-public interface IHolder<ContainedType> {
+public interface IHolder<ContainedType> extends Functor<ContainedType> {
 	/**
 	 * Bind a function across the value in this container
 	 * 
@@ -22,8 +25,8 @@ public interface IHolder<ContainedType> {
 	 *            The function to bind to the value
 	 * @return A holder from binding the value
 	 */
-	public <BoundType> IHolder<BoundType> bind(
-			Function<ContainedType, IHolder<BoundType>> binder);
+	public <BoundType> IHolder<BoundType>
+			bind(Function<ContainedType, IHolder<BoundType>> binder);
 
 	/**
 	 * Apply an action to the value
@@ -31,7 +34,7 @@ public interface IHolder<ContainedType> {
 	 * @param action
 	 *            The action to apply to the value
 	 */
-	public default void doWith(Consumer<ContainedType> action) {
+	public default void doWith(Consumer<? super ContainedType> action) {
 		transform((value) -> {
 			action.accept(value);
 
@@ -39,13 +42,64 @@ public interface IHolder<ContainedType> {
 		});
 	}
 
+	@Override
+	default <ArgType, ReturnType>
+			Function<Functor<ArgType>, Functor<ReturnType>>
+			fmap(Function<ArgType, ReturnType> func) {
+		return (argumentFunctor) -> {
+			if (!(argumentFunctor instanceof IHolder<?>)) {
+				throw new IllegalArgumentException(
+						"This functor only supports mapping over instances of IHolder");
+			}
+
+			IHolder<ArgType> holder = (IHolder<ArgType>) argumentFunctor;
+
+			return holder.map(func);
+		};
+	}
+
+	@Override
+	public default ContainedType getValue() {
+		return unwrap((value) -> value);
+	}
+
 	/**
-	 * Get the value contained in this holder without changing it.
+	 * Lifts a function to bind over this holder
 	 * 
-	 * @return The value held in this holder
+	 * @param <NewType>
+	 *            The type of the functions return
+	 * @param func
+	 *            The function to lift over the holder
+	 * @return The function lifted over the holder
 	 */
-	public default ContainedType getValue() {
-		return unwrap((value) -> value);
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(Function<ContainedType, NewType> func);
+
+	/**
+	 * Make this holder lazy
+	 * 
+	 * @return A lazy version of this holder
+	 */
+	public default IHolder<ContainedType> makeLazy() {
+		return new WrappedLazy<>(this);
+	}
+
+	/**
+	 * Make this holder a list
+	 * 
+	 * @return A list version of this holder
+	 */
+	public default IHolder<ContainedType> makeList() {
+		return new BoundListHolder<>(new FunctionalList<>(this));
+	}
+
+	/**
+	 * Make this holder optional
+	 * 
+	 * @return An optional version of this holder
+	 */
+	public default IHolder<ContainedType> makeOptional() {
+		return new WrappedOption<>(this);
 	}
 
 	/**
@@ -60,8 +114,8 @@ public interface IHolder<ContainedType> {
 	 *            The function to do mapping with
 	 * @return A holder with the mapped value
 	 */
-	public <MappedType> IHolder<MappedType> map(
-			Function<ContainedType, MappedType> mapper);
+	public <MappedType> IHolder<MappedType>
+			map(Function<ContainedType, MappedType> mapper);
 
 	/**
 	 * Replace the held value with a new one
@@ -83,8 +137,8 @@ public interface IHolder<ContainedType> {
 	 *            The function to transform the value with
 	 * @return The holder itself, for easy chaining
 	 */
-	public IHolder<ContainedType> transform(
-			UnaryOperator<ContainedType> transformer);
+	public IHolder<ContainedType>
+			transform(UnaryOperator<ContainedType> transformer);
 
 	/**
 	 * Unwrap the value contained in this holder so that it is no longer
@@ -96,6 +150,6 @@ public interface IHolder<ContainedType> {
 	 *            The function to use to unwrap the value
 	 * @return The unwrapped held value
 	 */
-	public <UnwrappedType> UnwrappedType unwrap(
-			Function<ContainedType, UnwrappedType> unwrapper);
+	public <UnwrappedType> UnwrappedType
+			unwrap(Function<ContainedType, UnwrappedType> unwrapper);
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java
index 316074e..707724b 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/IPair.java
@@ -4,6 +4,8 @@ import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 
+import bjc.utils.funcdata.theory.Bifunctor;
+
 /**
  * Represents a pair of values
  * 
@@ -14,7 +16,8 @@ import java.util.function.Function;
  *            The type of the right side of the pair
  *
  */
-public interface IPair<LeftType, RightType> {
+public interface IPair<LeftType, RightType>
+		extends Bifunctor<LeftType, RightType> {
 	/**
 	 * Bind a function across the values in this pair
 	 * 
@@ -68,11 +71,45 @@ public interface IPair<LeftType, RightType> {
 		});
 	}
 
+	@Override
+	default <OldLeft, OldRight, NewLeft>
+			Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, OldRight>>
+			fmapLeft(Function<OldLeft, NewLeft> func) {
+		return (argumentPair) -> {
+			if (!(argumentPair instanceof IPair<?, ?>)) {
+				throw new IllegalArgumentException(
+						"This function can only be applied to instances of IPair");
+			}
+
+			IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair;
+
+			return argPair.mapLeft(func);
+		};
+	}
+
+	@Override
+	default <OldLeft, OldRight, NewRight>
+			Function<Bifunctor<OldLeft, OldRight>, Bifunctor<OldLeft, NewRight>>
+
+			fmapRight(Function<OldRight, NewRight> func) {
+		return (argumentPair) -> {
+			if (!(argumentPair instanceof IPair<?, ?>)) {
+				throw new IllegalArgumentException(
+						"This function can only be applied to instances of IPair");
+			}
+
+			IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair;
+
+			return argPair.mapRight(func);
+		};
+	}
+
 	/**
 	 * Get the value on the left side of the pair
 	 * 
 	 * @return The value on the left side of the pair
 	 */
+	@Override
 	public default LeftType getLeft() {
 		return merge((leftValue, rightValue) -> leftValue);
 	}
@@ -82,11 +119,40 @@ public interface IPair<LeftType, RightType> {
 	 * 
 	 * @return The value on the right side of the pair
 	 */
+	@Override
 	public default RightType getRight() {
 		return merge((leftValue, rightValue) -> rightValue);
 	}
 
 	/**
+	 * Transform the value on the left side of the pair. Doesn't modify the
+	 * pair
+	 * 
+	 * @param <NewLeft>
+	 *            The new type of the left part of the pair
+	 * @param mapper
+	 *            The function to use to transform the left part of the
+	 *            pair
+	 * @return The pair, with its left part transformed
+	 */
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(Function<LeftType, NewLeft> mapper);
+
+	/**
+	 * Transform the value on the right side of the pair. Doesn't modify
+	 * the pair
+	 * 
+	 * @param <NewRight>
+	 *            The new type of the right part of the pair
+	 * @param mapper
+	 *            The function to use to transform the right part of the
+	 *            pair
+	 * @return The pair, with its right part transformed
+	 */
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(Function<RightType, NewRight> mapper);
+
+	/**
 	 * Merge the two values in this pair into a single value
 	 * 
 	 * @param <MergedType>
@@ -95,6 +161,6 @@ public interface IPair<LeftType, RightType> {
 	 *            The function to use for merging
 	 * @return The pair, merged into a single value
 	 */
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger);
+	public <MergedType> MergedType
+			merge(BiFunction<LeftType, RightType, MergedType> merger);
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Identity.java b/BJC-Utils2/src/main/java/bjc/utils/data/Identity.java
index dcc7bef..f42ceb7 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Identity.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Identity.java
@@ -112,4 +112,12 @@ public class Identity<ContainedType> implements IHolder<ContainedType> {
 			Function<ContainedType, UnwrappedType> unwrapper) {
 		return unwrapper.apply(heldValue);
 	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new Identity<>(func.apply(val));
+		};
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java
index 061486e..62b0bb0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java
@@ -133,4 +133,13 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 
 		return unwrapper.apply(heldValue);
 	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		// TODO Auto-generated method stub
+		return (val) -> {
+			return new Lazy<>(func.apply(val));
+		};
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
index b02d9cb..6f1be10 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
@@ -115,8 +115,8 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		if (!leftMaterialized) {
 			leftValue = leftSupplier.get();
 
@@ -154,4 +154,48 @@ public class LazyPair<LeftType, RightType>
 
 		return sb.toString();
 	}
+
+	@Override
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(Function<LeftType, NewLeft> mapper) {
+		Supplier<NewLeft> leftSupp = () -> {
+			if (leftMaterialized) {
+				return mapper.apply(leftValue);
+			}
+
+			return mapper.apply(leftSupplier.get());
+		};
+
+		Supplier<RightType> rightSupp = () -> {
+			if (rightMaterialized) {
+				return rightValue;
+			}
+
+			return rightSupplier.get();
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
+
+	@Override
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(Function<RightType, NewRight> mapper) {
+		Supplier<LeftType> leftSupp = () -> {
+			if (leftMaterialized) {
+				return leftValue;
+			}
+
+			return leftSupplier.get();
+		};
+
+		Supplier<NewRight> rightSupp = () -> {
+			if (rightMaterialized) {
+				return mapper.apply(rightValue);
+			}
+
+			return mapper.apply(rightSupplier.get());
+		};
+
+		return new LazyPair<>(leftSupp, rightSupp);
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java
new file mode 100644
index 0000000..8dc33d3
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java
@@ -0,0 +1,79 @@
+package bjc.utils.data;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.IFunctionalList;
+
+/**
+ * A holder that represents a set of non-deterministic computations
+ * 
+ * @author ben
+ *
+ * @param <ContainedType>
+ *            The type of contained value
+ */
+public class ListHolder<ContainedType> implements IHolder<ContainedType> {
+	private IFunctionalList<ContainedType> heldValues;
+
+	private ListHolder(IFunctionalList<ContainedType> toHold) {
+		heldValues = toHold;
+	}
+
+	/**
+	 * Create a new list holder
+	 * 
+	 * @param values
+	 *            The possible values for the computation
+	 */
+	@SafeVarargs
+	public ListHolder(ContainedType... values) {
+		heldValues = new FunctionalList<>();
+
+		if (values != null) {
+			for (ContainedType containedValue : values) {
+				heldValues.add(containedValue);
+			}
+		}
+	}
+
+	@Override
+	public <BoundType> IHolder<BoundType> bind(
+			Function<ContainedType, IHolder<BoundType>> binder) {
+		IFunctionalList<IHolder<BoundType>> boundValues = heldValues
+				.map(binder);
+
+		return new BoundListHolder<>(boundValues);
+	}
+
+	@Override
+	public <MappedType> IHolder<MappedType> map(
+			Function<ContainedType, MappedType> mapper) {
+		IFunctionalList<MappedType> mappedValues = heldValues.map(mapper);
+
+		return new ListHolder<>(mappedValues);
+	}
+
+	@Override
+	public IHolder<ContainedType> transform(
+			UnaryOperator<ContainedType> transformer) {
+		heldValues = heldValues.map(transformer);
+
+		return this;
+	}
+
+	@Override
+	public <UnwrappedType> UnwrappedType unwrap(
+			Function<ContainedType, UnwrappedType> unwrapper) {
+		return unwrapper.apply(heldValues.randItem());
+	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new ListHolder<>(new FunctionalList<>(func.apply(val)));
+		};
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Option.java b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java
new file mode 100644
index 0000000..9f6d448
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java
@@ -0,0 +1,74 @@
+package bjc.utils.data;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+/**
+ * A holder that may or may not contain a value
+ * 
+ * @author ben
+ *
+ * @param <ContainedType>
+ *            The type of the value that may or may not be held
+ */
+public class Option<ContainedType> implements IHolder<ContainedType> {
+	private ContainedType held;
+
+	/**
+	 * Create a new optional, using the given initial value
+	 * 
+	 * @param seedValue
+	 *            The initial value for the optional
+	 */
+	public Option(ContainedType seedValue) {
+		held = seedValue;
+	}
+
+	@Override
+	public <BoundType> IHolder<BoundType> bind(
+			Function<ContainedType, IHolder<BoundType>> binder) {
+		if (held == null) {
+			return new Option<>(null);
+		}
+
+		return binder.apply(held);
+	}
+
+	@Override
+	public <MappedType> IHolder<MappedType> map(
+			Function<ContainedType, MappedType> mapper) {
+		if (held == null) {
+			return new Option<>(null);
+		}
+
+		return new Option<>(mapper.apply(held));
+	}
+
+	@Override
+	public IHolder<ContainedType> transform(
+			UnaryOperator<ContainedType> transformer) {
+		if (held != null) {
+			held = transformer.apply(held);
+		}
+
+		return this;
+	}
+
+	@Override
+	public <UnwrappedType> UnwrappedType unwrap(
+			Function<ContainedType, UnwrappedType> unwrapper) {
+		if (held == null) {
+			return null;
+		}
+
+		return unwrapper.apply(held);
+	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new Option<>(func.apply(val));
+		};
+	}
+}
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 05955b6..0d2c1b0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
@@ -56,8 +56,8 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType
+			merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		return merger.apply(leftValue, rightValue);
 	}
 
@@ -66,4 +66,16 @@ public class Pair<LeftType, RightType>
 		return "pair[l=" + leftValue.toString() + ", r="
 				+ rightValue.toString() + "]";
 	}
+
+	@Override
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(Function<LeftType, NewLeft> mapper) {
+		return new Pair<>(mapper.apply(leftValue), rightValue);
+	}
+
+	@Override
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(Function<RightType, NewRight> mapper) {
+		return new Pair<>(leftValue, mapper.apply(rightValue));
+	}
 }
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java
new file mode 100644
index 0000000..737482c
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java
@@ -0,0 +1,69 @@
+package bjc.utils.data;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
+	private IHolder<IHolder<ContainedType>> held;
+
+	// This has an extra parameter, because otherwise it erases to the same
+	// as the public one
+	private WrappedLazy(IHolder<IHolder<ContainedType>> wrappedHolder,
+			@SuppressWarnings("unused") boolean dummy) {
+		held = wrappedHolder;
+	}
+
+	public WrappedLazy(IHolder<ContainedType> wrappedHolder) {
+		held = new Lazy<>(wrappedHolder);
+	}
+
+	@Override
+	public <BoundType> IHolder<BoundType> bind(
+			Function<ContainedType, IHolder<BoundType>> binder) {
+		IHolder<IHolder<BoundType>> newHolder = held
+				.map((containedHolder) -> {
+					return containedHolder.bind(binder);
+				});
+
+		return new WrappedLazy<>(newHolder, false);
+	}
+
+	@Override
+	public <MappedType> IHolder<MappedType> map(
+			Function<ContainedType, MappedType> mapper) {
+		IHolder<IHolder<MappedType>> newHolder = held
+				.map((containedHolder) -> {
+					return containedHolder.map(mapper);
+				});
+
+		return new WrappedLazy<>(newHolder, false);
+	}
+
+	@Override
+	public IHolder<ContainedType> transform(
+			UnaryOperator<ContainedType> transformer) {
+		// FIXME this smells bad to me, but I can't figure out how else to
+		// do it
+		held.transform((containedHolder) -> {
+			return containedHolder.transform(transformer);
+		});
+
+		return this;
+	}
+
+	@Override
+	public <UnwrappedType> UnwrappedType unwrap(
+			Function<ContainedType, UnwrappedType> unwrapper) {
+		return held.unwrap((containedHolder) -> {
+			return containedHolder.unwrap(unwrapper);
+		});
+	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new Lazy<>(func.apply(val));
+		};
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java
new file mode 100644
index 0000000..c36cafa
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java
@@ -0,0 +1,89 @@
+package bjc.utils.data;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+class WrappedOption<ContainedType> implements IHolder<ContainedType> {
+	private IHolder<IHolder<ContainedType>> held;
+
+	private WrappedOption(IHolder<IHolder<ContainedType>> toHold,
+			@SuppressWarnings("unused") boolean dummy) {
+		held = toHold;
+	}
+
+	public WrappedOption(IHolder<ContainedType> seedValue) {
+		held = new Option<>(seedValue);
+	}
+
+	@Override
+	public <BoundType> IHolder<BoundType> bind(
+			Function<ContainedType, IHolder<BoundType>> binder) {
+		IHolder<IHolder<BoundType>> newHolder = held
+				.map((containedHolder) -> {
+					return containedHolder.bind((containedValue) -> {
+						if (containedValue == null) {
+							return new Option<>(null);
+						}
+
+						return binder.apply(containedValue);
+					});
+				});
+
+		return new WrappedOption<>(newHolder, false);
+	}
+
+	@Override
+	public <MappedType> IHolder<MappedType> map(
+			Function<ContainedType, MappedType> mapper) {
+		IHolder<IHolder<MappedType>> newHolder = held
+				.map((containedHolder) -> {
+					return containedHolder.map((containedValue) -> {
+						if (containedValue == null) {
+							return null;
+						}
+
+						return mapper.apply(containedValue);
+					});
+				});
+
+		return new WrappedOption<>(newHolder, false);
+	}
+
+	@Override
+	public IHolder<ContainedType> transform(
+			UnaryOperator<ContainedType> transformer) {
+		held.transform((containedHolder) -> {
+			return containedHolder.transform((containedValue) -> {
+				if (containedValue == null) {
+					return null;
+				}
+
+				return transformer.apply(containedValue);
+			});
+		});
+
+		return this;
+	}
+
+	@Override
+	public <UnwrappedType> UnwrappedType unwrap(
+			Function<ContainedType, UnwrappedType> unwrapper) {
+		return held.unwrap((containedHolder) -> {
+			return containedHolder.unwrap((containedValue) -> {
+				if (containedValue == null) {
+					return null;
+				}
+
+				return unwrapper.apply(containedValue);
+			});
+		});
+	}
+
+	@Override
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
+			Function<ContainedType, NewType> func) {
+		return (val) -> {
+			return new Option<>(func.apply(val));
+		};
+	}
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java
index 91b2ba3..5327dbe 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/IFunctionalList.java
@@ -246,6 +246,16 @@ public interface IFunctionalList<ContainedType> {
 	ContainedType randItem(Function<Integer, Integer> rnd);
 
 	/**
+	 * Select a random item from the list, using a default random number
+	 * generator
+	 * 
+	 * @return A random item from the list
+	 */
+	default ContainedType randItem() {
+		return randItem((num) -> (int) (Math.random() * num));
+	}
+
+	/**
 	 * Reduce this list to a single value, using a accumulative approach.
 	 * 
 	 * @param <StateType>
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java
new file mode 100644
index 0000000..cc31923
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/PushdownMap.java
@@ -0,0 +1,91 @@
+package bjc.utils.funcdata;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+/**
+ * A map where
+ * 
+ * @author ben
+ *
+ * @param <KeyType>
+ * @param <ValueType>
+ */
+public class PushdownMap<KeyType, ValueType>
+		implements IFunctionalMap<KeyType, ValueType> {
+
+	@Override
+	public boolean containsKey(KeyType key) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public IFunctionalMap<KeyType, ValueType> extend() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public void forEach(BiConsumer<KeyType, ValueType> action) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void forEachKey(Consumer<KeyType> action) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void forEachValue(Consumer<ValueType> action) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public ValueType get(KeyType key) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public int getSize() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	@Override
+	public IFunctionalList<KeyType> keyList() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public <V2> IFunctionalMap<KeyType, V2> mapValues(
+			Function<ValueType, V2> transformer) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public ValueType put(KeyType key, ValueType val) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public ValueType remove(KeyType key) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public IFunctionalList<ValueType> valueList() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
new file mode 100644
index 0000000..3bea135
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
@@ -0,0 +1,66 @@
+package bjc.utils.funcdata.theory;
+
+import java.util.function.Function;
+
+/**
+ * A functor over a pair of heterogenous types
+ * 
+ * @author ben
+ * @param <LeftType>
+ *            The type stored on the 'left' of the pair
+ * @param <RightType>
+ *            The type stored on the 'right' of the pair
+ *
+ */
+public interface Bifunctor<LeftType, RightType> {
+	/**
+	 * Lift a function to operate over the left part of this pair
+	 * 
+	 * @param <OldLeft>
+	 *            The old left type of the pair
+	 * @param <OldRight>
+	 *            The old right type of the pair
+	 * @param <NewLeft>
+	 *            The new left type of the pair
+	 * @param func
+	 *            The function to lift to work over the left side of the
+	 *            pair
+	 * @return The function lifted to work over the left side of bifunctors
+	 */
+	public <OldLeft, OldRight, NewLeft>
+			Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, OldRight>>
+			fmapLeft(Function<OldLeft, NewLeft> func);
+
+	/**
+	 * Lift a function to operate over the right part of this pair
+	 * 
+	 * @param <OldLeft>
+	 *            The old left type of the pair
+	 * @param <OldRight>
+	 *            The old right type of the pair
+	 * @param <NewRight>
+	 *            The new right type of the pair
+	 * @param func
+	 *            The function to lift to work over the right side of the
+	 *            pair
+	 * @return The function lifted to work over the right side of
+	 *         bifunctors
+	 */
+	public <OldLeft, OldRight, NewRight>
+			Function<Bifunctor<OldLeft, OldRight>, Bifunctor<OldLeft, NewRight>>
+			fmapRight(Function<OldRight, NewRight> func);
+
+	/**
+	 * Get the value contained on the left of this bifunctor
+	 * 
+	 * @return The value on the left side of this bifunctor
+	 */
+	public LeftType getLeft();
+
+	/**
+	 * Get the value contained on the right of this bifunctor
+	 * 
+	 * @return The value on the right of this bifunctor
+	 */
+	public RightType getRight();
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java
new file mode 100644
index 0000000..76f48e2
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java
@@ -0,0 +1,39 @@
+package bjc.utils.funcdata.theory;
+
+import java.util.function.Function;
+
+/**
+ * Represents a container or context some sort usually, but the precise
+ * definition is that it represents exactly what it is defined as
+ * 
+ * @author ben
+ * @param <ContainedType>
+ *            The value inside the functor
+ */
+public interface Functor<ContainedType> {
+	/**
+	 * Converts a normal function to operate over values in a functor.
+	 * 
+	 * N.B: Even though the type signature implies that you can apply the
+	 * resulting function to any type of functor, it is only safe to call
+	 * it on instances of the type of functor you called fmap on.
+	 * 
+	 * @param <ArgType>
+	 *            The argument of the function
+	 * @param <ReturnType>
+	 *            The return type of the function
+	 * @param func
+	 *            The function to convert
+	 * @return The passed in function converted to work over a particular
+	 *         type of functors
+	 */
+	public <ArgType, ReturnType> Function<Functor<ArgType>, Functor<ReturnType>> fmap(
+			Function<ArgType, ReturnType> func);
+
+	/**
+	 * Retrieve the thing inside this functor
+	 * 
+	 * @return The thing inside this functor
+	 */
+	public ContainedType getValue();
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java
new file mode 100644
index 0000000..33c80d6
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/package-info.java
@@ -0,0 +1,7 @@
+/**
+ * Random functional type things that don't belong elsewhere
+ * 
+ * @author ben
+ *
+ */
+package bjc.utils.funcdata.theory;
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
index 2f8aa09..9401b7e 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcutils/StringUtils.java
@@ -74,8 +74,14 @@ public class StringUtils {
 		}
 	}
 
+	/**
+	 * Print out a deque with a special case for easily showing a deque is empty
+	 * @param <ContainedType> The type in the deque
+	 * @param queue The deque to print
+	 * @return A string version of the deque, with allowance for an empty deque
+	 */
 	public static <ContainedType> String printDeque(
-			Deque<ContainedType> queuedTrees) {
-		return queuedTrees.isEmpty() ? "(none)" : queuedTrees.toString();
+			Deque<ContainedType> queue) {
+		return queue.isEmpty() ? "(none)" : queue.toString();
 	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/gui/HolderOutputPanel.java b/BJC-Utils2/src/main/java/bjc/utils/gui/HolderOutputPanel.java
index 4cbfb61..49c7283 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/gui/HolderOutputPanel.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/gui/HolderOutputPanel.java
@@ -17,25 +17,31 @@ public class HolderOutputPanel extends JPanel {
 	private static final long	serialVersionUID	= 166573313903782080L;
 	private Timer				updateTimer;
 	private JLabel				value;
+	private int					nDelay;
+	private IHolder<String>		val;
 
 	/**
 	 * Create a new display panel, backed by a holder
 	 * 
 	 * @param lab
 	 *            The label to attach to this field
-	 * @param val
+	 * @param valueHolder
 	 *            The holder to get the value from
 	 * @param nDelay
 	 *            The delay in ms between value updates
 	 */
-	public HolderOutputPanel(String lab, IHolder<String> val, int nDelay) {
+	public HolderOutputPanel(String lab, IHolder<String> valueHolder,
+			int nDelay) {
+		this.val = valueHolder;
+		this.nDelay = nDelay;
+
 		setLayout(new HLayout(2));
 
 		JLabel label = new JLabel(lab);
-		value = new JLabel(val.getValue() + " (stopped)");
+		value = new JLabel("(stopped)");
 
 		updateTimer = new Timer(nDelay, (event) -> {
-			value.setText(val.getValue());
+			value.setText(valueHolder.getValue());
 		});
 
 		add(label);
@@ -57,4 +63,17 @@ public class HolderOutputPanel extends JPanel {
 
 		value.setText(value.getText() + " (stopped)");
 	}
+
+	/**
+	 * Set this panel back to its initial state
+	 */
+	public void reset() {
+		stopUpdating();
+
+		value.setText("(stopped)");
+
+		updateTimer = new Timer(nDelay, (event) -> {
+			value.setText(val.getValue());
+		});
+	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/StackBasedConfigReader.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/StackBasedConfigReader.java
new file mode 100644
index 0000000..2d15711
--- /dev/null
+++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/StackBasedConfigReader.java
@@ -0,0 +1,37 @@
+package bjc.utils.parserutils;
+
+/**
+ * This class parses a config file written in RPN and uses it to construct
+ * data items
+ * 
+ * @author ben
+ *
+ *         TODO implement me
+ */
+public class StackBasedConfigReader {
+	public static interface IItem {
+		public ItemType getType();
+	}
+
+	/**
+	 * Represents the types of item that can be found on stacks
+	 * 
+	 * @author ben
+	 *
+	 */
+	public static enum ItemType {
+		/**
+		 * Represents an integral number
+		 */
+		INTEGER,
+		/**
+		 * Represents a string of characters
+		 */
+		STRING,
+		/**
+		 * Represents an arbitrary object
+		 */
+		OBJECT
+	}
+
+}