Update

9 files changed, 121 insertions, 197 deletions

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 53428d9..f20139e 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
@@ -14,8 +14,6 @@ import java.util.function.Supplier;
  * @param <RightType>
  *            The type on the right side of the pair
  * 
- * @TODO ensure we don't have any issues with values being materialized
- *       more than once
  */
 public class LazyPair<LeftType, RightType>
 		implements IPair<LeftType, RightType> {
@@ -54,6 +52,7 @@ public class LazyPair<LeftType, RightType>
 	 */
 	public LazyPair(Supplier<LeftType> leftSupp,
 			Supplier<RightType> rightSupp) {
+		// Use single suppliers to catch double-instantiation bugs
 		leftSupplier = new SingleSupplier<>(leftSupp);
 		rightSupplier = new SingleSupplier<>(rightSupp);
 
@@ -63,14 +62,12 @@ public class LazyPair<LeftType, RightType>
 
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
-			BiFunction<LeftType, RightType,
-					IPair<BoundLeft, BoundRight>> binder) {
+			BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
 		return new BoundLazyPair<>(leftSupplier, rightSupplier, binder);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
 		Supplier<LeftType> leftSupp = () -> {
 			if (leftMaterialized) {
 				return leftValue;
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java
index fc6180b..e7ae1fc 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/ListHolder.java
@@ -39,40 +39,35 @@ public class ListHolder<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(
-			Function<ContainedType, IHolder<BoundType>> binder) {
+	public <BoundType> IHolder<BoundType> bind(Function<ContainedType, IHolder<BoundType>> binder) {
 		IList<IHolder<BoundType>> boundValues = heldValues.map(binder);
 
 		return new BoundListHolder<>(boundValues);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
-			Function<ContainedType, NewType> func) {
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(Function<ContainedType, NewType> func) {
 		return (val) -> {
 			return new ListHolder<>(new FunctionalList<>(func.apply(val)));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(
-			Function<ContainedType, MappedType> mapper) {
+	public <MappedType> IHolder<MappedType> map(Function<ContainedType, MappedType> mapper) {
 		IList<MappedType> mappedValues = heldValues.map(mapper);
 
 		return new ListHolder<>(mappedValues);
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(
-			UnaryOperator<ContainedType> transformer) {
+	public IHolder<ContainedType> transform(UnaryOperator<ContainedType> transformer) {
 		heldValues = heldValues.map(transformer);
 
 		return this;
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(
-			Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType unwrap(Function<ContainedType, UnwrappedType> unwrapper) {
 		return unwrapper.apply(heldValues.randItem());
 	}
 }
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Option.java b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java
index 16d90e3..33b6327 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Option.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Option.java
@@ -17,16 +17,15 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	/**
 	 * Create a new optional, using the given initial value
 	 * 
-	 * @param seedValue
+	 * @param seed
 	 *            The initial value for the optional
 	 */
-	public Option(ContainedType seedValue) {
-		held = seedValue;
+	public Option(ContainedType seed) {
+		held = seed;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(
-			Function<ContainedType, IHolder<BoundType>> binder) {
+	public <BoundType> IHolder<BoundType> bind(Function<ContainedType, IHolder<BoundType>> binder) {
 		if (held == null) {
 			return new Option<>(null);
 		}
@@ -35,16 +34,14 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(
-			Function<ContainedType, NewType> func) {
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(Function<ContainedType, NewType> func) {
 		return (val) -> {
 			return new Option<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(
-			Function<ContainedType, MappedType> mapper) {
+	public <MappedType> IHolder<MappedType> map(Function<ContainedType, MappedType> mapper) {
 		if (held == null) {
 			return new Option<>(null);
 		}
@@ -53,8 +50,7 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(
-			UnaryOperator<ContainedType> transformer) {
+	public IHolder<ContainedType> transform(UnaryOperator<ContainedType> transformer) {
 		if (held != null) {
 			held = transformer.apply(held);
 		}
@@ -63,8 +59,7 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(
-			Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType unwrap(Function<ContainedType, UnwrappedType> unwrapper) {
 		if (held == null) {
 			return null;
 		}
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 3480b2a..74040e8 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Pair.java
@@ -13,10 +13,10 @@ import java.util.function.Function;
  * @param <RightType>
  *            The type of the right value
  */
-public class Pair<LeftType, RightType>
-		implements IPair<LeftType, RightType> {
+public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	// The left value
 	private LeftType	leftValue;
+
 	// The right value
 	private RightType	rightValue;
 
@@ -24,6 +24,7 @@ public class Pair<LeftType, RightType>
 	 * Create a new pair with both sides set to null
 	 */
 	public Pair() {
+
 	}
 
 	/**
@@ -41,8 +42,7 @@ public class Pair<LeftType, RightType>
 
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
-			BiFunction<LeftType, RightType,
-					IPair<BoundLeft, BoundRight>> binder) {
+			BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
 		if (binder == null) {
 			throw new NullPointerException("Binder must not be null.");
 		}
@@ -51,8 +51,7 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
 		if (leftBinder == null) {
 			throw new NullPointerException("Binder must not be null");
 		}
@@ -61,8 +60,7 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
-			Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
+	public <BoundRight> IPair<LeftType, BoundRight> bindRight(Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
 		if (rightBinder == null) {
 			throw new NullPointerException("Binder must not be null");
 		}
@@ -71,22 +69,17 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft,
-			CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-					IPair<OtherLeft, OtherRight> otherPair,
-					BiFunction<LeftType, OtherLeft,
-							CombinedLeft> leftCombiner,
-					BiFunction<RightType, OtherRight,
-							CombinedRight> rightCombiner) {
-		return otherPair.bind((otherLeft, otherRight) -> {
-			return new Pair<>(leftCombiner.apply(leftValue, otherLeft),
-					rightCombiner.apply(rightValue, otherRight));
-		});
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
+			IPair<OtherLeft, OtherRight> otherPair,
+			BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+			BiFunction<RightType, OtherRight, CombinedRight> rightCombiner) {
+				return otherPair.bind((otherLeft, otherRight) -> {
+					return new Pair<>(leftCombiner.apply(leftValue, otherLeft), rightCombiner.apply(rightValue, otherRight));
+				});
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType> mapLeft(
-			Function<LeftType, NewLeft> mapper) {
+	public <NewLeft> IPair<NewLeft, RightType> mapLeft(Function<LeftType, NewLeft> mapper) {
 		if (mapper == null) {
 			throw new NullPointerException("Mapper must not be null");
 		}
@@ -95,8 +88,7 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight> mapRight(
-			Function<RightType, NewRight> mapper) {
+	public <NewRight> IPair<LeftType, NewRight> mapRight(Function<RightType, NewRight> mapper) {
 		if (mapper == null) {
 			throw new NullPointerException("Mapper must not be null");
 		}
@@ -105,8 +97,7 @@ public class Pair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		if (merger == null) {
 			throw new NullPointerException("Merger must not be null");
 		}
@@ -116,7 +107,6 @@ public class Pair<LeftType, RightType>
 
 	@Override
 	public String toString() {
-		return "pair[l=" + leftValue.toString() + ", r="
-				+ rightValue.toString() + "]";
+		return "pair[l=" + leftValue.toString() + ", r=" + rightValue.toString() + "]";
 	}
-}
\ No newline at end of file
+}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java b/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java
index ad00496..b5ff1e3 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/SingleSupplier.java
@@ -55,8 +55,7 @@ public class SingleSupplier<T> implements Supplier<T> {
 		gotten = true;
 
 		try {
-			throw new IllegalStateException(
-					"Previous instantiation here.");
+			throw new IllegalStateException("Previous instantiation here.");
 		} catch (IllegalStateException isex) {
 			instSite = isex;
 		}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java b/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java
index a2448d2..e72cdf6 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/TopDownTransformResult.java
@@ -8,7 +8,7 @@ package bjc.utils.data;
  */
 public enum TopDownTransformResult {
 	/**
-	 * Do not do anything to this node, and ignore it's children
+	 * Do not do anything to this node, and ignore its children
 	 */
 	SKIP,
 	/**
@@ -20,7 +20,7 @@ public enum TopDownTransformResult {
 	 */
 	PASSTHROUGH,
 	/**
-	 * Traverse this nodes children, then transform it
+	 * Traverse the nodes of this children, then transform it
 	 */
 	PUSHDOWN,
 	/**
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java b/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java
index 46fb1a6..b812650 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/Tree.java
@@ -19,20 +19,19 @@ import bjc.utils.funcutils.StringUtils;
  */
 public class Tree<ContainedType> implements ITree<ContainedType> {
 	private ContainedType				data;
-	private IList<ITree<ContainedType>>	children;
 
+	private IList<ITree<ContainedType>>	children;
 	private boolean						hasChildren;
-
 	private int							childCount	= 0;
 
 	/**
 	 * Create a new leaf node in a tree
 	 * 
-	 * @param leafToken
+	 * @param leaf
 	 *            The data to store as a leaf node
 	 */
-	public Tree(ContainedType leafToken) {
-		data = leafToken;
+	public Tree(ContainedType leaf) {
+		data = leaf;
 
 		hasChildren = false;
 	}
@@ -40,14 +39,13 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	/**
 	 * Create a new tree node with the specified children
 	 * 
-	 * @param leafToken
+	 * @param leaf
 	 *            The data to hold in this node
 	 * @param childrn
 	 *            A list of children for this node
 	 */
-	public Tree(ContainedType leafToken,
-			IList<ITree<ContainedType>> childrn) {
-		data = leafToken;
+	public Tree(ContainedType leaf, IList<ITree<ContainedType>> childrn) {
+		data = leaf;
 
 		hasChildren = true;
 
@@ -59,14 +57,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	/**
 	 * Create a new tree node with the specified children
 	 * 
-	 * @param leafToken
+	 * @param leaf
 	 *            The data to hold in this node
 	 * @param childrn
 	 *            A list of children for this node
 	 */
 	@SafeVarargs
-	public Tree(ContainedType leafToken, ITree<ContainedType>... childrn) {
-		data = leafToken;
+	public Tree(ContainedType leaf, ITree<ContainedType>... childrn) {
+		data = leaf;
 
 		hasChildren = true;
 
@@ -97,12 +95,10 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	@Override
 	public <NewType, ReturnedType> ReturnedType collapse(
 			Function<ContainedType, NewType> leafTransform,
-			Function<ContainedType,
-					Function<IList<NewType>, NewType>> nodeCollapser,
+			Function<ContainedType, Function<IList<NewType>, NewType>> nodeCollapser,
 			Function<NewType, ReturnedType> resultTransformer) {
 
-		return resultTransformer
-				.apply(internalCollapse(leafTransform, nodeCollapser));
+		return resultTransformer.apply(internalCollapse(leafTransform, nodeCollapser));
 	}
 
 	@Override
@@ -111,8 +107,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	}
 
 	@Override
-	public ITree<ContainedType> flatMapTree(
-			Function<ContainedType, ITree<ContainedType>> mapper) {
+	public ITree<ContainedType> flatMapTree(Function<ContainedType, ITree<ContainedType>> mapper) {
 		if (hasChildren) {
 			ITree<ContainedType> flatMappedData = mapper.apply(data);
 
@@ -132,17 +127,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	protected <NewType> NewType internalCollapse(
 			Function<ContainedType, NewType> leafTransform,
-			Function<ContainedType,
-					Function<IList<NewType>, NewType>> nodeCollapser) {
+			Function<ContainedType, Function<IList<NewType>, NewType>> nodeCollapser) {
 		if (hasChildren) {
-			Function<IList<NewType>,
-					NewType> nodeTransformer = nodeCollapser.apply(data);
+			Function<IList<NewType>, NewType> nodeTransformer = nodeCollapser.apply(data);
 
-			IList<NewType> collapsedChildren = (IList<NewType>) children
-					.map((child) -> {
-						return child.collapse(leafTransform, nodeCollapser,
-								(subTreeVal) -> subTreeVal);
-					});
+			IList<NewType> collapsedChildren = (IList<NewType>) children.map((child) -> {
+				return child.collapse(leafTransform, nodeCollapser,
+					(subTreeVal) -> subTreeVal);
+			});
 
 			return nodeTransformer.apply(collapsedChildren);
 		}
@@ -150,8 +142,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 		return leafTransform.apply(data);
 	}
 
-	protected void internalToString(StringBuilder builder, int indentLevel,
-			boolean initial) {
+	protected void internalToString(StringBuilder builder, int indentLevel, boolean initial) {
 		if (!initial) {
 			StringUtils.indentNLevels(builder, indentLevel);
 		}
@@ -162,8 +153,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 		if (hasChildren) {
 			children.forEach((child) -> {
-				((Tree<ContainedType>) child).internalToString(builder,
-						indentLevel + 2, false);
+				((Tree<ContainedType>) child).internalToString(builder, indentLevel + 2, false);
 			});
 		}
 	}
@@ -173,25 +163,21 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			Function<ContainedType, MappedType> leafTransformer,
 			Function<ContainedType, MappedType> operatorTransformer) {
 		if (hasChildren) {
-			IList<ITree<MappedType>> mappedChildren = children
-					.map((child) -> {
-						return child.rebuildTree(leafTransformer,
-								operatorTransformer);
-					});
+			IList<ITree<MappedType>> mappedChildren = children.map((child) -> {
+				return child.rebuildTree(leafTransformer,
+					operatorTransformer);
+			});
 
-			return new Tree<>(operatorTransformer.apply(data),
-					mappedChildren);
+			return new Tree<>(operatorTransformer.apply(data), mappedChildren);
 		}
 
 		return new Tree<>(leafTransformer.apply(data));
 	}
 
 	@Override
-	public void selectiveTransform(Predicate<ContainedType> nodePicker,
-			UnaryOperator<ContainedType> transformer) {
+	public void selectiveTransform(Predicate<ContainedType> nodePicker, UnaryOperator<ContainedType> transformer) {
 		if (hasChildren) {
-			children.forEach((child) -> child
-					.selectiveTransform(nodePicker, transformer));
+			children.forEach((child) -> child.selectiveTransform(nodePicker, transformer));
 		} else {
 			data = transformer.apply(data);
 		}
@@ -199,11 +185,9 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public ITree<ContainedType> topDownTransform(
-			Function<ContainedType,
-					TopDownTransformResult> transformPicker,
+			Function<ContainedType, TopDownTransformResult> transformPicker,
 			UnaryOperator<ITree<ContainedType>> transformer) {
-		TopDownTransformResult transformResult = transformPicker
-				.apply(data);
+		TopDownTransformResult transformResult = transformPicker.apply(data);
 
 		switch (transformResult) {
 			case PASSTHROUGH:
@@ -211,8 +195,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 				if (hasChildren) {
 					children.forEach((child) -> {
-						result.addChild(child.topDownTransform(
-								transformPicker, transformer));
+						result.addChild(child.topDownTransform(transformPicker, transformer));
 					});
 				}
 
@@ -226,28 +209,23 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 				if (hasChildren) {
 					children.forEach((child) -> {
-						result.addChild(child.topDownTransform(
-								transformPicker, transformer));
+						result.addChild(child.topDownTransform(transformPicker, transformer));
 					});
 				}
 
 				return transformer.apply(result);
 			case PULLUP:
-				ITree<ContainedType> intermediateResult = transformer
-						.apply(this);
+				ITree<ContainedType> intermediateResult = transformer.apply(this);
 
 				result = new Tree<>(intermediateResult.getHead());
 
 				intermediateResult.doForChildren((child) -> {
-					result.addChild(child.topDownTransform(transformPicker,
-							transformer));
+					result.addChild(child.topDownTransform(transformPicker, transformer));
 				});
 
 				return result;
 			default:
-				throw new IllegalArgumentException(
-						"Recieved unknown transform result "
-								+ transformResult);
+				throw new IllegalArgumentException("Recieved unknown transform result " + transformResult);
 
 		}
 	}
@@ -264,66 +242,55 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	}
 
 	@Override
-	public <TransformedType> TransformedType transformChild(int childNo,
-			Function<ITree<ContainedType>, TransformedType> transformer) {
+	public <TransformedType> TransformedType transformChild(
+			int childNo, Function<ITree<ContainedType>, TransformedType> transformer) {
 		if (childNo < 0 || childNo > (childCount - 1)) {
-			throw new IllegalArgumentException(
-					"Child index #" + childNo + " is invalid");
+			throw new IllegalArgumentException("Child index #" + childNo + " is invalid");
 		}
 
 		return transformer.apply(children.getByIndex(childNo));
 	}
 
 	@Override
-	public <TransformedType> TransformedType transformHead(
-			Function<ContainedType, TransformedType> transformer) {
+	public <TransformedType> TransformedType transformHead(Function<ContainedType, TransformedType> transformer) {
 		return transformer.apply(data);
 	}
 
 	@Override
-	public <MappedType> ITree<MappedType> transformTree(
-			Function<ContainedType, MappedType> transformer) {
+	public <MappedType> ITree<MappedType> transformTree(Function<ContainedType, MappedType> transformer) {
 		if (hasChildren) {
-			IList<ITree<MappedType>> transformedChildren = children
-					.map((child) -> child.transformTree(transformer));
+			IList<ITree<MappedType>> transformedChildren = children.map((child) -> child.transformTree(transformer));
 
-			return new Tree<>(transformer.apply(data),
-					transformedChildren);
+			return new Tree<>(transformer.apply(data), transformedChildren);
 		}
 
 		return new Tree<>(transformer.apply(data));
 	}
 
 	@Override
-	public void traverse(TreeLinearizationMethod linearizationMethod,
-			Consumer<ContainedType> action) {
+	public void traverse(TreeLinearizationMethod linearizationMethod, Consumer<ContainedType> action) {
 		if (hasChildren) {
 			switch (linearizationMethod) {
 				case INORDER:
 					if (childCount != 2) {
-						throw new IllegalArgumentException(
-								"Can only do in-order traversal for binary trees.");
+						throw new IllegalArgumentException("Can only do in-order traversal for binary trees.");
 					}
 
-					children.getByIndex(0).traverse(linearizationMethod,
-							action);
+					children.getByIndex(0).traverse(linearizationMethod, action);
 
 					action.accept(data);
 
-					children.getByIndex(1).traverse(linearizationMethod,
-							action);
+					children.getByIndex(1).traverse(linearizationMethod, action);
 					break;
 				case POSTORDER:
-					children.forEach((child) -> child
-							.traverse(linearizationMethod, action));
+					children.forEach((child) -> child.traverse(linearizationMethod, action));
 
 					action.accept(data);
 					break;
 				case PREORDER:
 					action.accept(data);
 
-					children.forEach((child) -> child
-							.traverse(linearizationMethod, action));
+					children.forEach((child) -> child.traverse(linearizationMethod, action));
 					break;
 				default:
 					break;
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java
index b894ac7..d278358 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedLazy.java
@@ -12,46 +12,37 @@ class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 
 	// This has an extra parameter, because otherwise it erases to the same
 	// as the public one
-	private WrappedLazy(IHolder<IHolder<ContainedType>> wrappedHolder,
-			boolean dummy) {
+	private WrappedLazy(IHolder<IHolder<ContainedType>> wrappedHolder, boolean dummy) {
 		held = wrappedHolder;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(
-			Function<ContainedType, IHolder<BoundType>> binder) {
-		IHolder<IHolder<BoundType>> newHolder = held
-				.map((containedHolder) -> {
-					return containedHolder.bind(binder);
-				});
+	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 <NewType> Function<ContainedType, IHolder<NewType>> lift(
-			Function<ContainedType, NewType> func) {
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(Function<ContainedType, NewType> func) {
 		return (val) -> {
 			return new Lazy<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(
-			Function<ContainedType, MappedType> mapper) {
-		IHolder<IHolder<MappedType>> newHolder = held
-				.map((containedHolder) -> {
-					return containedHolder.map(mapper);
-				});
+	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
+	public IHolder<ContainedType> transform(UnaryOperator<ContainedType> transformer) {
 		held.transform((containedHolder) -> {
 			return containedHolder.transform(transformer);
 		});
@@ -60,8 +51,7 @@ class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(
-			Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType unwrap(Function<ContainedType, UnwrappedType> unwrapper) {
 		return held.unwrap((containedHolder) -> {
 			return containedHolder.unwrap(unwrapper);
 		});
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java
index fea4cb9..554eb54 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/WrappedOption.java
@@ -10,56 +10,48 @@ class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 		held = new Option<>(seedValue);
 	}
 
-	private WrappedOption(IHolder<IHolder<ContainedType>> toHold,
-			boolean dummy) {
+	private WrappedOption(IHolder<IHolder<ContainedType>> toHold, boolean dummy) {
 		held = toHold;
 	}
 
-	@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);
-					});
-				});
+	@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 <NewType> Function<ContainedType, IHolder<NewType>> lift(
-			Function<ContainedType, NewType> func) {
+	public <NewType> Function<ContainedType, IHolder<NewType>> lift(Function<ContainedType, NewType> func) {
 		return (val) -> {
 			return new Option<>(func.apply(val));
 		};
 	}
 
 	@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);
-					});
-				});
+	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) {
+	public IHolder<ContainedType> transform(UnaryOperator<ContainedType> transformer) {
 		held.transform((containedHolder) -> {
 			return containedHolder.transform((containedValue) -> {
 				if (containedValue == null) {
@@ -74,8 +66,7 @@ class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(
-			Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType unwrap(Function<ContainedType, UnwrappedType> unwrapper) {
 		return held.unwrap((containedHolder) -> {
 			return containedHolder.unwrap((containedValue) -> {
 				if (containedValue == null) {