Cleanup pass

Pass to do some cleanups

29 files changed, 921 insertions, 712 deletions

diff --git a/src/main/java/bjc/data/ArrayIterator.java b/src/main/java/bjc/data/ArrayIterator.java
index 6037e34..6d11a1d 100644
--- a/src/main/java/bjc/data/ArrayIterator.java
+++ b/src/main/java/bjc/data/ArrayIterator.java
@@ -1,22 +1,24 @@
 package bjc.data;
 
 import java.util.Iterator;
+
 /**
  * Represents an iterator over an array of values.
  *
- * @param <T> The type of values in the array.
- * 
+ * @param <T>
+ *            The type of values in the array.
+ *
  * @author Ben Culkin
  */
 public class ArrayIterator<T> implements Iterator<T> {
 	private Object[] arr;
-	private int      idx;
+	private int idx;
 
 	/**
 	 * Create a new array iterator.
 	 *
 	 * @param elms
-	 * 	The array that will be iterated over.
+	 *             The array that will be iterated over.
 	 */
 	@SafeVarargs
 	public ArrayIterator(T... elms) {
@@ -32,8 +34,9 @@ public class ArrayIterator<T> implements Iterator<T> {
 	@SuppressWarnings("unchecked")
 	@Override
 	public T next() {
-		if (idx >= arr.length) return null;
+		if (idx >= arr.length)
+			return null;
 
-		return (T)(arr[idx++]);
+		return (T) (arr[idx++]);
 	}
 }
diff --git a/src/main/java/bjc/data/BooleanToggle.java b/src/main/java/bjc/data/BooleanToggle.java
index 209e97c..af083f5 100644
--- a/src/main/java/bjc/data/BooleanToggle.java
+++ b/src/main/java/bjc/data/BooleanToggle.java
@@ -21,7 +21,7 @@ public class BooleanToggle implements Toggle<Boolean> {
 	 * Create a flip-flop with the specified initial value.
 	 *
 	 * @param initial
-	 *        The initial value of the flip-flop.
+	 *                The initial value of the flip-flop.
 	 */
 	public BooleanToggle(final boolean initial) {
 		val = initial;
@@ -59,13 +59,17 @@ public class BooleanToggle implements Toggle<Boolean> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof BooleanToggle)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof BooleanToggle))
+			return false;
 
 		final BooleanToggle other = (BooleanToggle) obj;
 
-		if(val != other.val) return false;
+		if (val != other.val)
+			return false;
 
 		return true;
 	}
diff --git a/src/main/java/bjc/data/CircularIterator.java b/src/main/java/bjc/data/CircularIterator.java
index 6842b26..ce6b4c3 100644
--- a/src/main/java/bjc/data/CircularIterator.java
+++ b/src/main/java/bjc/data/CircularIterator.java
@@ -8,7 +8,7 @@ import java.util.Iterator;
  * @author EVE
  *
  * @param <E>
- *                The type of the iterable.
+ *            The type of the iterable.
  */
 public class CircularIterator<E> implements Iterator<E> {
 	/* The iterable, and our current iterator into it. */
@@ -19,8 +19,7 @@ public class CircularIterator<E> implements Iterator<E> {
 	private E curElm;
 
 	/*
-	 * Should we actually get new iterators, or just repeat the last
-	 * element?
+	 * Should we actually get new iterators, or just repeat the last element?
 	 */
 	private boolean doCircle;
 
@@ -28,11 +27,11 @@ public class CircularIterator<E> implements Iterator<E> {
 	 * Create a new circular iterator.
 	 *
 	 * @param src
-	 *                The iterable to iterate from.
+	 *             The iterable to iterate from.
 	 *
 	 * @param circ
-	 *                Should we actually do circular iteration, or just
-	 *                repeat the terminal element?
+	 *             Should we actually do circular iteration, or just repeat the
+	 *             terminal element?
 	 */
 	public CircularIterator(final Iterable<E> src, final boolean circ) {
 		source = src;
@@ -45,7 +44,7 @@ public class CircularIterator<E> implements Iterator<E> {
 	 * Create a new circular iterator that does actual circular iteration.
 	 *
 	 * @param src
-	 *                The iterable to iterate from.
+	 *            The iterable to iterate from.
 	 */
 	public CircularIterator(final Iterable<E> src) {
 		this(src, true);
@@ -63,7 +62,7 @@ public class CircularIterator<E> implements Iterator<E> {
 			if (!doCircle) {
 				return curElm;
 			}
-			
+
 			curr = source.iterator();
 		}
 
diff --git a/src/main/java/bjc/data/Either.java b/src/main/java/bjc/data/Either.java
index 0588496..55518d8 100644
--- a/src/main/java/bjc/data/Either.java
+++ b/src/main/java/bjc/data/Either.java
@@ -9,10 +9,10 @@ import java.util.function.Function;
  * @author ben
  *
  * @param <LeftType>
- *        The type that could be on the left.
+ *                    The type that could be on the left.
  *
  * @param <RightType>
- *        The type that could be on the right.
+ *                    The type that could be on the right.
  *
  */
 public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
@@ -20,17 +20,18 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 	 * Create a new either with the left value occupied.
 	 *
 	 * @param <LeftType>
-	 *        The type of the left value.
+	 *                    The type of the left value.
 	 *
 	 * @param <RightType>
-	 *        The type of the empty right value.
-	 * 
+	 *                    The type of the empty right value.
+	 *
 	 * @param left
-	 *        The value to put on the left.
+	 *                    The value to put on the left.
 	 *
 	 * @return An either with the left side occupied.
 	 */
-	public static <LeftType, RightType> Either<LeftType, RightType> left(final LeftType left) {
+	public static <LeftType, RightType> Either<LeftType, RightType>
+			left(final LeftType left) {
 		return new Either<>(left, null);
 	}
 
@@ -38,17 +39,18 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 	 * Create a new either with the right value occupied.
 	 *
 	 * @param <LeftType>
-	 *        The type of the empty left value.
+	 *                    The type of the empty left value.
 	 *
 	 * @param <RightType>
-	 *        The type of the right value.
+	 *                    The type of the right value.
 	 *
 	 * @param right
-	 *        The value to put on the right.
+	 *                    The value to put on the right.
 	 *
 	 * @return An either with the right side occupied.
 	 */
-	public static <LeftType, RightType> Either<LeftType, RightType> right(final RightType right) {
+	public static <LeftType, RightType> Either<LeftType, RightType>
+			right(final RightType right) {
 		return new Either<>(null, right);
 	}
 
@@ -61,7 +63,7 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 
 	/* Create a new either with specifed values. */
 	private Either(final LeftType left, final RightType right) {
-		if(left == null) {
+		if (left == null) {
 			rightVal = right;
 		} else {
 			leftVal = left;
@@ -73,17 +75,20 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
 			final BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
-		if(binder == null) throw new NullPointerException("Binder must not be null");
+		if (binder == null)
+			throw new NullPointerException("Binder must not be null");
 
 		return binder.apply(leftVal, rightVal);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
-		if(leftBinder == null) throw new NullPointerException("Left binder must not be null");
+	public <BoundLeft> IPair<BoundLeft, RightType>
+			bindLeft(final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+		if (leftBinder == null)
+			throw new NullPointerException("Left binder must not be null");
 
-		if(isLeft) return leftBinder.apply(leftVal);
+		if (isLeft)
+			return leftBinder.apply(leftVal);
 
 		return new Either<>(null, rightVal);
 	}
@@ -91,27 +96,31 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 	@Override
 	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
 			final Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
-		if(rightBinder == null) throw new NullPointerException("Right binder must not be null");
+		if (rightBinder == null)
+			throw new NullPointerException("Right binder must not be null");
 
-		if(isLeft) return new Either<>(leftVal, null);
+		if (isLeft)
+			return new Either<>(leftVal, null);
 
 		return rightBinder.apply(rightVal);
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			final IPair<OtherLeft, OtherRight> otherPair,
-			final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
-			final BiFunction<RightType, OtherRight, CombinedRight> rightCombiner) {
-		if(otherPair == null) {
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(final IPair<OtherLeft, OtherRight> otherPair,
+					final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+					final BiFunction<RightType, OtherRight,
+							CombinedRight> rightCombiner) {
+		if (otherPair == null) {
 			throw new NullPointerException("Other pair must not be null");
-		} else if(leftCombiner == null) {
+		} else if (leftCombiner == null) {
 			throw new NullPointerException("Left combiner must not be null");
-		} else if(rightCombiner == null) {
+		} else if (rightCombiner == null) {
 			throw new NullPointerException("Right combiner must not be null");
 		}
 
-		if(isLeft) {
+		if (isLeft) {
 			return otherPair.bind((otherLeft, otherRight) -> {
 				CombinedLeft cLeft = leftCombiner.apply(leftVal, otherLeft);
 
@@ -127,26 +136,34 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType> mapLeft(final Function<LeftType, NewLeft> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(final Function<LeftType, NewLeft> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
-		if(isLeft) return new Either<>(mapper.apply(leftVal), null);
+		if (isLeft)
+			return new Either<>(mapper.apply(leftVal), null);
 
 		return new Either<>(null, rightVal);
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight> mapRight(final Function<RightType, NewRight> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(final Function<RightType, NewRight> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
-		if(isLeft) return new Either<>(leftVal, null);
+		if (isLeft)
+			return new Either<>(leftVal, null);
 
 		return new Either<>(null, mapper.apply(rightVal));
 	}
 
 	@Override
-	public <MergedType> MergedType merge(final BiFunction<LeftType, RightType, MergedType> merger) {
-		if(merger == null) throw new NullPointerException("Merger must not be null");
+	public <MergedType> MergedType
+			merge(final BiFunction<LeftType, RightType, MergedType> merger) {
+		if (merger == null)
+			throw new NullPointerException("Merger must not be null");
 
 		return merger.apply(leftVal, rightVal);
 	}
@@ -165,27 +182,36 @@ public class Either<LeftType, RightType> implements IPair<LeftType, RightType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Either<?, ?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Either<?, ?>))
+			return false;
 
 		final Either<?, ?> other = (Either<?, ?>) obj;
 
-		if(isLeft != other.isLeft) return false;
+		if (isLeft != other.isLeft)
+			return false;
 
-		if(leftVal == null) {
-			if(other.leftVal != null) return false;
-		} else if(!leftVal.equals(other.leftVal)) return false;
+		if (leftVal == null) {
+			if (other.leftVal != null)
+				return false;
+		} else if (!leftVal.equals(other.leftVal))
+			return false;
 
-		if(rightVal == null) {
-			if(other.rightVal != null) return false;
-		} else if(!rightVal.equals(other.rightVal)) return false;
+		if (rightVal == null) {
+			if (other.rightVal != null)
+				return false;
+		} else if (!rightVal.equals(other.rightVal))
+			return false;
 
 		return true;
 	}
 
 	@Override
 	public String toString() {
-		return String.format("Either [leftVal='%s', rightVal='%s', isLeft=%s]", leftVal, rightVal, isLeft);
+		return String.format("Either [leftVal='%s', rightVal='%s', isLeft=%s]", leftVal,
+				rightVal, isLeft);
 	}
 }
diff --git a/src/main/java/bjc/data/GeneratingIterator.java b/src/main/java/bjc/data/GeneratingIterator.java
index 9adda6f..ffa92cf 100644
--- a/src/main/java/bjc/data/GeneratingIterator.java
+++ b/src/main/java/bjc/data/GeneratingIterator.java
@@ -6,11 +6,11 @@ import java.util.function.UnaryOperator;
 
 /**
  * An iterator that generates a series of elements from a single element.
- * 
+ *
  * @author bjculkin
  *
  * @param <E>
- *        The type of element generated.
+ *            The type of element generated.
  */
 public class GeneratingIterator<E> implements Iterator<E> {
 	/* Our current state. */
@@ -22,18 +22,19 @@ public class GeneratingIterator<E> implements Iterator<E> {
 
 	/**
 	 * Create a new generative iterator.
-	 * 
+	 *
 	 * @param initial
-	 *        The initial state of the generator.
-	 * 
+	 *                   The initial state of the generator.
+	 *
 	 * @param transition
-	 *        The function to apply to the state.
-	 * 
+	 *                   The function to apply to the state.
+	 *
 	 * @param stopper
-	 *        The predicate applied to the current state to determine when
-	 *        to stop.
+	 *                   The predicate applied to the current state to determine
+	 *                   when to stop.
 	 */
-	public GeneratingIterator(E initial, UnaryOperator<E> transition, Predicate<E> stopper) {
+	public GeneratingIterator(E initial, UnaryOperator<E> transition,
+			Predicate<E> stopper) {
 		state = initial;
 		transtion = transition;
 		stpper = stopper;
@@ -47,9 +48,9 @@ public class GeneratingIterator<E> implements Iterator<E> {
 	/*
 	 * @NOTE
 	 *
-	 * As this currently is, it only works correctly assuming that next() is
-	 * only called when hasNext() is true. Should we safeguard against
-	 * people who are not doing the right thing?
+	 * As this currently is, it only works correctly assuming that next() is only
+	 * called when hasNext() is true. Should we safeguard against people who are not
+	 * doing the right thing?
 	 */
 	@Override
 	public E next() {
diff --git a/src/main/java/bjc/data/IHolder.java b/src/main/java/bjc/data/IHolder.java
index e56e23e..faa3f64 100644
--- a/src/main/java/bjc/data/IHolder.java
+++ b/src/main/java/bjc/data/IHolder.java
@@ -16,27 +16,28 @@ import bjc.funcdata.theory.Functor;
  * @author ben
  *
  * @param <ContainedType>
- *        The type of value held.
+ *                        The type of value held.
  */
 public interface IHolder<ContainedType> extends Functor<ContainedType> {
 	/**
 	 * Bind a function across the value in this container.
 	 *
 	 * @param <BoundType>
-	 *        The type of value in this container.
+	 *                    The type of value in this container.
 	 *
 	 * @param binder
-	 *        The function to bind to the value.
+	 *                    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.
 	 *
 	 * @param action
-	 *        The action to apply to the value.
+	 *               The action to apply to the value.
 	 */
 	public default void doWith(final Consumer<? super ContainedType> action) {
 		transform(value -> {
@@ -47,11 +48,12 @@ public interface IHolder<ContainedType> extends Functor<ContainedType> {
 	}
 
 	@Override
-	default <ArgType, ReturnType> Function<Functor<ArgType>, Functor<ReturnType>> fmap(
-			final Function<ArgType, ReturnType> func) {
+	default <ArgType, ReturnType> Function<Functor<ArgType>, Functor<ReturnType>>
+			fmap(final Function<ArgType, ReturnType> func) {
 		return argumentFunctor -> {
-			if(!(argumentFunctor instanceof IHolder<?>)) {
-				final String msg = "This functor only supports mapping over instances of IHolder";
+			if (!(argumentFunctor instanceof IHolder<?>)) {
+				final String msg
+						= "This functor only supports mapping over instances of IHolder";
 
 				throw new IllegalArgumentException(msg);
 			}
@@ -71,14 +73,15 @@ public interface IHolder<ContainedType> extends Functor<ContainedType> {
 	 * Lifts a function to bind over this holder.
 	 *
 	 * @param <NewType>
-	 *        The type of the functions return.
+	 *                  The type of the functions return.
 	 *
 	 * @param func
-	 *        The function to lift over the holder.
+	 *                  The function to lift over the holder.
 	 *
 	 * @return The function lifted over the holder.
 	 */
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(Function<ContainedType, NewType> func);
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(Function<ContainedType, NewType> func);
 
 	/**
 	 * Make this holder lazy.
@@ -108,56 +111,54 @@ public interface IHolder<ContainedType> extends Functor<ContainedType> {
 	}
 
 	/**
-	 * Create a new holder with a mapped version of the value in this
-	 * holder.
+	 * Create a new holder with a mapped version of the value in this holder.
 	 *
 	 * Does not change the internal state of this holder.
 	 *
 	 * @param <MappedType>
-	 *        The type of the mapped value.
+	 *                     The type of the mapped value.
 	 *
 	 * @param mapper
-	 *        The function to do mapping with.
+	 *                     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.
 	 *
 	 * @param newValue
-	 *        The value to hold instead.
+	 *                 The value to hold instead.
 	 *
 	 * @return The holder itself.
 	 */
 	public default IHolder<ContainedType> replace(final ContainedType newValue) {
-		return transform(oldValue -> {
-			return newValue;
-		});
+		return transform(oldValue -> newValue);
 	}
 
 	/**
 	 * Transform the value held in this holder.
 	 *
 	 * @param transformer
-	 *        The function to transform the value with.
+	 *                    The function to transform the value with.
 	 *
 	 * @return The holder itself, for easy chaining.
 	 */
 	public IHolder<ContainedType> transform(UnaryOperator<ContainedType> transformer);
 
 	/**
-	 * Unwrap the value contained in this holder so that it is no longer
-	 * held.
+	 * Unwrap the value contained in this holder so that it is no longer held.
 	 *
 	 * @param <UnwrappedType>
-	 *        The type of the unwrapped value.
+	 *                        The type of the unwrapped value.
 	 *
 	 * @param unwrapper
-	 *        The function to use to unwrap the value.
+	 *                        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/src/main/java/bjc/data/IPair.java b/src/main/java/bjc/data/IPair.java
index 0c63f16..5b1298e 100644
--- a/src/main/java/bjc/data/IPair.java
+++ b/src/main/java/bjc/data/IPair.java
@@ -12,10 +12,10 @@ import bjc.funcdata.theory.Bifunctor;
  * @author ben
  *
  * @param <LeftType>
- *                The type of the left side of the pair.
+ *                    The type of the left side of the pair.
  *
  * @param <RightType>
- *                The type of the right side of the pair.
+ *                    The type of the right side of the pair.
  *
  */
 public interface IPair<LeftType, RightType> extends Bifunctor<LeftType, RightType> {
@@ -23,103 +23,105 @@ public interface IPair<LeftType, RightType> extends Bifunctor<LeftType, RightTyp
 	 * Bind a function across the values in this pair.
 	 *
 	 * @param <BoundLeft>
-	 *                The type of the bound left.
+	 *                     The type of the bound left.
 	 *
 	 * @param <BoundRight>
-	 *                The type of the bound right.
+	 *                     The type of the bound right.
 	 *
 	 * @param binder
-	 *                The function to bind with.
+	 *                     The function to bind with.
 	 *
 	 * @return The bound pair.
 	 */
-	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
-			BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder);
+	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight>
+			bind(BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder);
 
 	/**
 	 * Bind a function to the left value in this pair.
 	 *
 	 * @param <BoundLeft>
-	 *                The type of the bound value.
+	 *                    The type of the bound value.
 	 *
 	 * @param leftBinder
-	 *                The function to use to bind.
+	 *                    The function to use to bind.
 	 *
 	 * @return A pair with the left type bound.
 	 */
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			Function<LeftType, IPair<BoundLeft, RightType>> leftBinder);
+	public <BoundLeft> IPair<BoundLeft, RightType>
+			bindLeft(Function<LeftType, IPair<BoundLeft, RightType>> leftBinder);
 
 	/**
 	 * Bind a function to the right value in this pair.
 	 *
 	 * @param <BoundRight>
-	 *                The type of the bound value.
+	 *                     The type of the bound value.
 	 *
 	 * @param rightBinder
-	 *                The function to use to bind.
+	 *                     The function to use to bind.
 	 *
 	 * @return A pair with the right type bound.
 	 */
-	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
-			Function<RightType, IPair<LeftType, BoundRight>> rightBinder);
+	public <BoundRight> IPair<LeftType, BoundRight>
+			bindRight(Function<RightType, IPair<LeftType, BoundRight>> rightBinder);
 
 	/**
 	 * Pairwise combine two pairs together.
 	 *
 	 * @param <OtherLeft>
-	 *                The left type of the other pair.
+	 *                     The left type of the other pair.
 	 *
 	 * @param <OtherRight>
-	 *                The right type of the other pair.
+	 *                     The right type of the other pair.
 	 *
 	 * @param otherPair
-	 *                The pair to combine with.
+	 *                     The pair to combine with.
 	 *
 	 * @return The pairs, pairwise combined together.
 	 */
-	public default <OtherLeft, OtherRight> IPair<IPair<LeftType, OtherLeft>, IPair<RightType, OtherRight>> combine(
-			final IPair<OtherLeft, OtherRight> otherPair) {
-		return combine(otherPair, Pair<LeftType, OtherLeft>::new, Pair<RightType, OtherRight>::new);
+	public default <OtherLeft, OtherRight>
+			IPair<IPair<LeftType, OtherLeft>, IPair<RightType, OtherRight>>
+			combine(final IPair<OtherLeft, OtherRight> otherPair) {
+		return combine(otherPair, Pair<LeftType, OtherLeft>::new,
+				Pair<RightType, OtherRight>::new);
 	}
 
 	/**
 	 * Combine the contents of two pairs together.
 	 *
 	 * @param <OtherLeft>
-	 *                The type of the left value of the other pair.
+	 *                        The type of the left value of the other pair.
 	 *
 	 * @param <OtherRight>
-	 *                The type of the right value of the other pair.
+	 *                        The type of the right value of the other pair.
 	 *
 	 * @param <CombinedLeft>
-	 *                The type of the left value of the combined pair.
+	 *                        The type of the left value of the combined pair.
 	 *
 	 * @param <CombinedRight>
-	 *                The type of the right value of the combined pair.
+	 *                        The type of the right value of the combined pair.
 	 *
 	 * @param otherPair
-	 *                The other pair to combine with.
+	 *                        The other pair to combine with.
 	 *
 	 * @param leftCombiner
-	 *                The function to combine the left values with.
+	 *                        The function to combine the left values with.
 	 *
 	 * @param rightCombiner
-	 *                The function to combine the right values with.
+	 *                        The function to combine the right values with.
 	 *
 	 * @return A pair with its values combined.
 	 */
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			IPair<OtherLeft, OtherRight> otherPair,
-			BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
-			BiFunction<RightType, OtherRight, CombinedRight> rightCombiner);
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(IPair<OtherLeft, OtherRight> otherPair,
+					BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+					BiFunction<RightType, OtherRight, CombinedRight> rightCombiner);
 
 	/**
-	 * Immediately perfom the specified action with the contents of this
-	 * pair.
+	 * Immediately perfom the specified action with the contents of this pair.
 	 *
 	 * @param consumer
-	 *                The action to perform on the pair.
+	 *                 The action to perform on the pair.
 	 */
 	public default void doWith(final BiConsumer<LeftType, RightType> consumer) {
 		merge((leftValue, rightValue) -> {
@@ -130,32 +132,36 @@ public interface IPair<LeftType, RightType> extends Bifunctor<LeftType, RightTyp
 	}
 
 	@Override
-	default <OldLeft, OldRight, NewLeft> LeftBifunctorMap<OldLeft, OldRight, NewLeft> fmapLeft(
-			final Function<OldLeft, NewLeft> func) {
+	default <OldLeft, OldRight, NewLeft> LeftBifunctorMap<OldLeft, OldRight, NewLeft>
+			fmapLeft(final Function<OldLeft, NewLeft> func) {
 		return argumentPair -> {
 			if (!(argumentPair instanceof IPair<?, ?>)) {
-				final String msg = "This function can only be applied to instances of IPair";
+				final String msg
+						= "This function can only be applied to instances of IPair";
 
 				throw new IllegalArgumentException(msg);
 			}
 
-			final IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair;
+			final IPair<OldLeft, OldRight> argPair
+					= (IPair<OldLeft, OldRight>) argumentPair;
 
 			return argPair.mapLeft(func);
 		};
 	}
 
 	@Override
-	default <OldLeft, OldRight, NewRight> RightBifunctorMap<OldLeft, OldRight, NewRight> fmapRight(
-			final Function<OldRight, NewRight> func) {
+	default <OldLeft, OldRight, NewRight> RightBifunctorMap<OldLeft, OldRight, NewRight>
+			fmapRight(final Function<OldRight, NewRight> func) {
 		return argumentPair -> {
 			if (!(argumentPair instanceof IPair<?, ?>)) {
-				final String msg = "This function can only be applied to instances of IPair";
+				final String msg
+						= "This function can only be applied to instances of IPair";
 
 				throw new IllegalArgumentException(msg);
 			}
 
-			final IPair<OldLeft, OldRight> argPair = (IPair<OldLeft, OldRight>) argumentPair;
+			final IPair<OldLeft, OldRight> argPair
+					= (IPair<OldLeft, OldRight>) argumentPair;
 
 			return argPair.mapRight(func);
 		};
@@ -187,15 +193,15 @@ public interface IPair<LeftType, RightType> extends Bifunctor<LeftType, RightTyp
 	 * Doesn't modify the pair.
 	 *
 	 * @param <NewLeft>
-	 *                The new type of the left part of the pair.
+	 *                  The new type of the left part of the pair.
 	 *
 	 * @param mapper
-	 *                The function to use to transform the left part of the
-	 *                pair.
+	 *                  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);
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(Function<LeftType, NewLeft> mapper);
 
 	/**
 	 * Transform the value on the right side of the pair.
@@ -203,36 +209,38 @@ public interface IPair<LeftType, RightType> extends Bifunctor<LeftType, RightTyp
 	 * Doesn't modify the pair.
 	 *
 	 * @param <NewRight>
-	 *                The new type of the right part of the pair.
+	 *                   The new type of the right part of the pair.
 	 *
 	 * @param mapper
-	 *                The function to use to transform the right part of the
-	 *                pair.
+	 *                   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);
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(Function<RightType, NewRight> mapper);
 
 	/**
 	 * Merge the two values in this pair into a single value.
 	 *
 	 * @param <MergedType>
-	 *                The type of the single value.
+	 *                     The type of the single value.
 	 *
 	 * @param merger
-	 *                The function to use for merging.
+	 *                     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);
 
 	/**
 	 * Static pair constructor.
-	 * 
+	 *
 	 * @param left
-	 *                The left side of the pair.
+	 *              The left side of the pair.
 	 * @param right
-	 *                The right side of the pair.
+	 *              The right side of the pair.
 	 * @return A pair, with the specified left/right side.
 	 */
 	public static <T1, T2> IPair<T1, T2> pair(T1 left, T2 right) {
diff --git a/src/main/java/bjc/data/ITree.java b/src/main/java/bjc/data/ITree.java
index 4088c10..e9c829e 100644
--- a/src/main/java/bjc/data/ITree.java
+++ b/src/main/java/bjc/data/ITree.java
@@ -15,7 +15,7 @@ import bjc.funcdata.bst.TreeLinearizationMethod;
  * @author ben
  *
  * @param <ContainedType>
- *        The type of data contained in the tree nodes.
+ *                        The type of data contained in the tree nodes.
  *
  */
 public interface ITree<ContainedType> {
@@ -23,7 +23,7 @@ public interface ITree<ContainedType> {
 	 * Append a child to this node.
 	 *
 	 * @param child
-	 *        The child to append to this node.
+	 *              The child to append to this node.
 	 */
 	void addChild(ITree<ContainedType> child);
 
@@ -31,7 +31,7 @@ public interface ITree<ContainedType> {
 	 * Append a child to this node.
 	 *
 	 * @param child
-	 *        The child to append to this node.
+	 *              The child to append to this node.
 	 */
 	void addChild(ContainedType child);
 
@@ -39,7 +39,7 @@ public interface ITree<ContainedType> {
 	 * Prepend a child to this node.
 	 *
 	 * @param child
-	 *        The child to prepend to this node.
+	 *              The child to prepend to this node.
 	 */
 	void prependChild(ITree<ContainedType> child);
 
@@ -47,25 +47,26 @@ public interface ITree<ContainedType> {
 	 * Collapse a tree into a single version.
 	 *
 	 * @param <NewType>
-	 *        The intermediate type being folded.
+	 *                          The intermediate type being folded.
 	 *
 	 * @param <ReturnedType>
-	 *        The type that is the end result.
+	 *                          The type that is the end result.
 	 *
 	 * @param leafTransform
-	 *        The function to use to convert leaf values.
+	 *                          The function to use to convert leaf values.
 	 *
 	 * @param nodeCollapser
-	 *        The function to use to convert internal nodes and their
-	 *        children.
+	 *                          The function to use to convert internal nodes and
+	 *                          their children.
 	 *
 	 * @param resultTransformer
-	 *        The function to use to convert a state to the returned
-	 *        version.
+	 *                          The function to use to convert a state to the
+	 *                          returned version.
 	 *
 	 * @return The final transformed state.
 	 */
-	<NewType, ReturnedType> ReturnedType collapse(Function<ContainedType, NewType> leafTransform,
+	<NewType, ReturnedType> ReturnedType collapse(
+			Function<ContainedType, NewType> leafTransform,
 			BiFunction<ContainedType, IList<NewType>, NewType> nodeCollapser,
 			Function<NewType, ReturnedType> resultTransformer);
 
@@ -73,22 +74,23 @@ public interface ITree<ContainedType> {
 	 * Execute a given action for each of this tree's children.
 	 *
 	 * @param action
-	 *        The action to execute for each child.
+	 *               The action to execute for each child.
 	 */
 	void doForChildren(Consumer<ITree<ContainedType>> action);
 
 	/**
-	 * Expand the nodes of a tree into trees, and then merge the contents of
-	 * those trees into a single tree.
+	 * Expand the nodes of a tree into trees, and then merge the contents of those
+	 * trees into a single tree.
 	 *
 	 * @param mapper
-	 *        The function to use to map values into trees.
+	 *               The function to use to map values into trees.
 	 *
 	 * @return A tree, with some nodes expanded into trees.
 	 */
-	default ITree<ContainedType> flatMapTree(final Function<ContainedType, ITree<ContainedType>> mapper) {
+	default ITree<ContainedType>
+			flatMapTree(final Function<ContainedType, ITree<ContainedType>> mapper) {
 		return topDownTransform(dat -> TopDownTransformResult.PUSHDOWN, node -> {
-			if(node.getChildrenCount() > 0) {
+			if (node.getChildrenCount() > 0) {
 				final ITree<ContainedType> parent = node.transformHead(mapper);
 
 				node.doForChildren(parent::addChild);
@@ -104,7 +106,7 @@ public interface ITree<ContainedType> {
 	 * Get the specified child of this tree.
 	 *
 	 * @param childNo
-	 *        The number of the child to get.
+	 *                The number of the child to get.
 	 *
 	 * @return The specified child of this tree.
 	 */
@@ -141,61 +143,64 @@ public interface ITree<ContainedType> {
 	 * Rebuild the tree with the same structure, but different nodes.
 	 *
 	 * @param <MappedType>
-	 *        The type of the new tree.
+	 *                            The type of the new tree.
 	 *
 	 * @param leafTransformer
-	 *        The function to use to transform leaf tokens.
+	 *                            The function to use to transform leaf tokens.
 	 *
 	 * @param internalTransformer
-	 *        The function to use to transform internal tokens.
+	 *                            The function to use to transform internal tokens.
 	 *
 	 * @return The tree, with the nodes changed.
 	 */
-	<MappedType> ITree<MappedType> rebuildTree(Function<ContainedType, MappedType> leafTransformer,
+	<MappedType> ITree<MappedType> rebuildTree(
+			Function<ContainedType, MappedType> leafTransformer,
 			Function<ContainedType, MappedType> internalTransformer);
 
 	/**
 	 * Transform some of the nodes in this tree.
 	 *
 	 * @param nodePicker
-	 *        The predicate to use to pick nodes to transform.
+	 *                    The predicate to use to pick nodes to transform.
 	 *
 	 * @param transformer
-	 *        The function to use to transform picked nodes.
+	 *                    The function to use to transform picked nodes.
 	 */
-	void selectiveTransform(Predicate<ContainedType> nodePicker, UnaryOperator<ContainedType> transformer);
+	void selectiveTransform(Predicate<ContainedType> nodePicker,
+			UnaryOperator<ContainedType> transformer);
 
 	/**
 	 * Do a top-down transform of the tree.
 	 *
 	 * @param transformPicker
-	 *        The function to use to pick how to progress.
+	 *                        The function to use to pick how to progress.
 	 *
 	 * @param transformer
-	 *        The function used to transform picked subtrees.
+	 *                        The function used to transform picked subtrees.
 	 *
 	 * @return The tree with the transform applied to picked subtrees.
 	 */
-	ITree<ContainedType> topDownTransform(Function<ContainedType, TopDownTransformResult> transformPicker,
+	ITree<ContainedType> topDownTransform(
+			Function<ContainedType, TopDownTransformResult> transformPicker,
 			UnaryOperator<ITree<ContainedType>> transformer);
 
 	/**
 	 * Transform one of this nodes children.
 	 *
 	 * @param <TransformedType>
-	 *        The type of the transformed value.
+	 *                          The type of the transformed value.
 	 *
 	 * @param childNo
-	 *        The number of the child to transform.
+	 *                          The number of the child to transform.
 	 *
 	 * @param transformer
-	 *        The function to use to transform the value.
+	 *                          The function to use to transform the value.
 	 *
 	 * @return The transformed value.
 	 *
 	 * @throws IllegalArgumentException
-	 *         if the childNo is out of bounds (0 &lt;= childNo &lt;=
-	 *         childCount()).
+	 *                                  if the childNo is out of bounds (0 &lt;=
+	 *                                  childNo &lt;= childCount()).
 	 */
 	<TransformedType> TransformedType transformChild(int childNo,
 			Function<ITree<ContainedType>, TransformedType> transformer);
@@ -204,27 +209,29 @@ public interface ITree<ContainedType> {
 	 * Transform the value that is the head of this node.
 	 *
 	 * @param <TransformedType>
-	 *        The type of the transformed value.
+	 *                          The type of the transformed value.
 	 *
 	 * @param transformer
-	 *        The function to use to transform the value.
+	 *                          The function to use to transform the value.
 	 *
 	 * @return The transformed value.
 	 */
-	<TransformedType> TransformedType transformHead(Function<ContainedType, TransformedType> transformer);
+	<TransformedType> TransformedType
+			transformHead(Function<ContainedType, TransformedType> transformer);
 
 	/**
 	 * Transform the tree into a tree with a different type of token.
 	 *
 	 * @param <MappedType>
-	 *        The type of the new tree.
+	 *                     The type of the new tree.
 	 *
 	 * @param transformer
-	 *        The function to use to transform tokens.
+	 *                     The function to use to transform tokens.
 	 *
 	 * @return A tree with the token types transformed.
 	 */
-	default <MappedType> ITree<MappedType> transformTree(final Function<ContainedType, MappedType> transformer) {
+	default <MappedType> ITree<MappedType>
+			transformTree(final Function<ContainedType, MappedType> transformer) {
 		return rebuildTree(transformer, transformer);
 	}
 
@@ -232,21 +239,22 @@ public interface ITree<ContainedType> {
 	 * Perform an action on each part of the tree.
 	 *
 	 * @param linearizationMethod
-	 *        The way to traverse the tree.
+	 *                            The way to traverse the tree.
 	 *
 	 * @param action
-	 *        The action to perform on each tree node.
+	 *                            The action to perform on each tree node.
 	 */
-	void traverse(TreeLinearizationMethod linearizationMethod, Consumer<ContainedType> action);
+	void traverse(TreeLinearizationMethod linearizationMethod,
+			Consumer<ContainedType> action);
 
 	/**
 	 * Find the farthest to right child that satisfies the given predicate.
 	 *
 	 * @param childPred
-	 *        The predicate to satisfy.
+	 *                  The predicate to satisfy.
 	 *
-	 * @return The index of the right-most child that satisfies the
-	 *         predicate, or -1 if one doesn't exist.
+	 * @return The index of the right-most child that satisfies the predicate, or -1
+	 *         if one doesn't exist.
 	 */
 	int revFind(Predicate<ITree<ContainedType>> childPred);
 
@@ -254,15 +262,16 @@ public interface ITree<ContainedType> {
 	 * Check if this tree contains any nodes that satisfy the predicate.
 	 *
 	 * @param pred
-	 *		The predicate to look for.
-	 * 
+	 *             The predicate to look for.
+	 *
 	 * @return Whether or not any items satisfied the predicate.
 	 */
 	default boolean containsMatching(Predicate<ContainedType> pred) {
 		Toggle<Boolean> tog = new OneWayToggle<>(false, true);
 
-		traverse(TreeLinearizationMethod.POSTORDER, (val) -> {
-			if(pred.test(val)) tog.get();
+		traverse(TreeLinearizationMethod.POSTORDER, val -> {
+			if (pred.test(val))
+				tog.get();
 		});
 
 		return tog.get();
@@ -272,7 +281,7 @@ public interface ITree<ContainedType> {
 	 * Set the head of the tree.
 	 *
 	 * @param dat
-	 *		The value to set as the head of the tree.
+	 *            The value to set as the head of the tree.
 	 */
 	void setHead(ContainedType dat);
 }
diff --git a/src/main/java/bjc/data/Identity.java b/src/main/java/bjc/data/Identity.java
index 8645c4c..c80c7e1 100644
--- a/src/main/java/bjc/data/Identity.java
+++ b/src/main/java/bjc/data/Identity.java
@@ -9,7 +9,7 @@ import java.util.function.UnaryOperator;
  * @author ben
  *
  * @param <ContainedType>
- *        The type contained in the holder.
+ *                        The type contained in the holder.
  */
 public class Identity<ContainedType> implements IHolder<ContainedType> {
 	/* The held value. */
@@ -24,14 +24,15 @@ public class Identity<ContainedType> implements IHolder<ContainedType> {
 	 * Create a holder holding the specified value.
 	 *
 	 * @param value
-	 *        The value to hold.
+	 *              The value to hold.
 	 */
 	public Identity(final ContainedType value) {
 		heldValue = value;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
 		return binder.apply(heldValue);
 	}
 
@@ -47,28 +48,35 @@ public class Identity<ContainedType> implements IHolder<ContainedType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Identity)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Identity))
+			return false;
 
 		final Identity<?> other = (Identity<?>) obj;
 
-		if(heldValue == null) {
-			if(other.heldValue != null) return false;
-		} else if(!heldValue.equals(other.heldValue)) return false;
+		if (heldValue == null) {
+			if (other.heldValue != null)
+				return false;
+		} else if (!heldValue.equals(other.heldValue))
+			return false;
 
 		return true;
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return (val) -> {
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> {
 			return new Identity<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
 		return new Identity<>(mapper.apply(heldValue));
 	}
 
@@ -78,14 +86,16 @@ public class Identity<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
 		heldValue = transformer.apply(heldValue);
 
 		return this;
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
 		return unwrapper.apply(heldValue);
 	}
 
@@ -93,7 +103,7 @@ public class Identity<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new identity container.
 	 *
 	 * @param val
-	 *        The contained value.
+	 *            The contained value.
 	 *
 	 * @return A new identity container.
 	 */
diff --git a/src/main/java/bjc/data/Lazy.java b/src/main/java/bjc/data/Lazy.java
index 0702665..a425232 100644
--- a/src/main/java/bjc/data/Lazy.java
+++ b/src/main/java/bjc/data/Lazy.java
@@ -15,7 +15,7 @@ import bjc.funcdata.IList;
  * @author ben
  *
  * @param <ContainedType>
- *        The type of the value being held.
+ *                        The type of the value being held.
  */
 public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	/* The supplier of the type. */
@@ -32,7 +32,7 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new lazy value from the specified seed value.
 	 *
 	 * @param value
-	 *        The seed value to use.
+	 *              The seed value to use.
 	 */
 	public Lazy(final ContainedType value) {
 		heldValue = value;
@@ -44,7 +44,7 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new lazy value from the specified value source.
 	 *
 	 * @param supp
-	 *        The source of a value to use.
+	 *             The source of a value to use.
 	 */
 	public Lazy(final Supplier<ContainedType> supp) {
 		valueSupplier = new SingleSupplier<>(supp);
@@ -53,38 +53,39 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	/* Create a new value from a supplier and a list of actions. */
-	private Lazy(final Supplier<ContainedType> supp, final IList<UnaryOperator<ContainedType>> pendingActions) {
+	private Lazy(final Supplier<ContainedType> supp,
+			final IList<UnaryOperator<ContainedType>> pendingActions) {
 		valueSupplier = supp;
 
 		actions = pendingActions;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
 		final IList<UnaryOperator<ContainedType>> pendingActions = new FunctionalList<>();
 
 		actions.forEach(pendingActions::add);
 
 		final Supplier<ContainedType> supplier = () -> {
-			if(valueMaterialized) return heldValue;
+			if (valueMaterialized)
+				return heldValue;
 
 			return valueSupplier.get();
 		};
 
-		return new BoundLazy<>(() -> {
-			return new Lazy<>(supplier, pendingActions);
-		}, binder);
+		return new BoundLazy<>(() -> new Lazy<>(supplier, pendingActions), binder);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return val -> {
-			return new Lazy<>(func.apply(val));
-		};
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> new Lazy<>(func.apply(val));
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
 		final IList<UnaryOperator<ContainedType>> pendingActions = new FunctionalList<>();
 
 		actions.forEach(pendingActions::add);
@@ -92,7 +93,7 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 		return new Lazy<>(() -> {
 			ContainedType currVal = heldValue;
 
-			if(!valueMaterialized) {
+			if (!valueMaterialized) {
 				currVal = valueSupplier.get();
 			}
 
@@ -103,8 +104,8 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 
 	@Override
 	public String toString() {
-		if(valueMaterialized) {
-			if(actions.isEmpty()) {
+		if (valueMaterialized) {
+			if (actions.isEmpty()) {
 				return String.format("value[v='%s']", heldValue);
 			}
 
@@ -115,15 +116,17 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
 		actions.add(transformer);
 
 		return this;
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		if(!valueMaterialized) {
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		if (!valueMaterialized) {
 			heldValue = valueSupplier.get();
 
 			valueMaterialized = true;
@@ -152,24 +155,32 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Lazy<?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Lazy<?>))
+			return false;
 
 		final Lazy<?> other = (Lazy<?>) obj;
 
-		if(valueMaterialized != other.valueMaterialized) return false;
+		if (valueMaterialized != other.valueMaterialized)
+			return false;
 
-		if(valueMaterialized) {
-			if(heldValue == null) {
-				if(other.heldValue != null) return false;
-			} else if(!heldValue.equals(other.heldValue)) return false;
+		if (valueMaterialized) {
+			if (heldValue == null) {
+				if (other.heldValue != null)
+					return false;
+			} else if (!heldValue.equals(other.heldValue))
+				return false;
 		} else
 			return false;
 
-		if(actions == null) {
-			if(other.actions != null) return false;
-		} else if(actions.getSize() > 0 || other.actions.getSize() > 0) return false;
+		if (actions == null) {
+			if (other.actions != null)
+				return false;
+		} else if (actions.getSize() > 0 || other.actions.getSize() > 0)
+			return false;
 
 		return true;
 	}
@@ -178,7 +189,7 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new lazy container with an already present value.
 	 *
 	 * @param val
-	 *        The value for the lazy container.
+	 *            The value for the lazy container.
 	 *
 	 * @return A new lazy container holding that value.
 	 */
@@ -190,12 +201,12 @@ public class Lazy<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new lazy container with a suspended value.
 	 *
 	 * @param supp
-	 *        The suspended value for the lazy container.
+	 *             The suspended value for the lazy container.
 	 *
-	 * @return A new lazy container that will un-suspend the value when
-	 *         necessary.
+	 * @return A new lazy container that will un-suspend the value when necessary.
 	 */
-	public static <ContainedType> Lazy<ContainedType> lazy(final Supplier<ContainedType> supp) {
+	public static <ContainedType> Lazy<ContainedType>
+			lazy(final Supplier<ContainedType> supp) {
 		return new Lazy<>(supp);
 	}
 }
diff --git a/src/main/java/bjc/data/LazyPair.java b/src/main/java/bjc/data/LazyPair.java
index 1633c65..e668cd4 100644
--- a/src/main/java/bjc/data/LazyPair.java
+++ b/src/main/java/bjc/data/LazyPair.java
@@ -13,10 +13,10 @@ import bjc.data.internals.HalfBoundLazyPair;
  * @author ben
  *
  * @param <LeftType>
- *        The type on the left side of the pair.
+ *                    The type on the left side of the pair.
  *
  * @param <RightType>
- *        The type on the right side of the pair.
+ *                    The type on the right side of the pair.
  */
 public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	/* The supplier for the left value. */
@@ -37,10 +37,10 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	 * Create a new lazy pair, using the set values.
 	 *
 	 * @param leftVal
-	 *        The value for the left side of the pair.
+	 *                 The value for the left side of the pair.
 	 *
 	 * @param rightVal
-	 *        The value for the right side of the pair.
+	 *                 The value for the right side of the pair.
 	 */
 	public LazyPair(final LeftType leftVal, final RightType rightVal) {
 		leftValue = leftVal;
@@ -54,12 +54,13 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	 * Create a new lazy pair from the given value sources.
 	 *
 	 * @param leftSupp
-	 *        The source for a value on the left side of the pair.
+	 *                  The source for a value on the left side of the pair.
 	 *
 	 * @param rightSupp
-	 *        The source for a value on the right side of the pair.
+	 *                  The source for a value on the right side of the pair.
 	 */
-	public LazyPair(final Supplier<LeftType> leftSupp, final Supplier<RightType> rightSupp) {
+	public LazyPair(final Supplier<LeftType> leftSupp,
+			final Supplier<RightType> rightSupp) {
 		/* Use single suppliers to catch double-instantiation bugs. */
 		leftSupplier = new SingleSupplier<>(leftSupp);
 		rightSupplier = new SingleSupplier<>(rightSupp);
@@ -75,10 +76,11 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+	public <BoundLeft> IPair<BoundLeft, RightType>
+			bindLeft(final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
 		final Supplier<LeftType> leftSupp = () -> {
-			if(leftMaterialized) return leftValue;
+			if (leftMaterialized)
+				return leftValue;
 
 			return leftSupplier.get();
 		};
@@ -90,7 +92,8 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
 			final Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
 		final Supplier<RightType> rightSupp = () -> {
-			if(rightMaterialized) return rightValue;
+			if (rightMaterialized)
+				return rightValue;
 
 			return rightSupplier.get();
 		};
@@ -99,23 +102,23 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			final IPair<OtherLeft, OtherRight> otherPair,
-			final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
-			final BiFunction<RightType, OtherRight, CombinedRight> rightCombiner) {
-		return otherPair.bind((otherLeft, otherRight) -> {
-			return bind((leftVal, rightVal) -> {
-				final CombinedLeft left = leftCombiner.apply(leftVal, otherLeft);
-				final CombinedRight right = rightCombiner.apply(rightVal, otherRight);
-
-				return new LazyPair<>(left, right);
-			});
-		});
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(final IPair<OtherLeft, OtherRight> otherPair,
+					final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+					final BiFunction<RightType, OtherRight,
+							CombinedRight> rightCombiner) {
+		return otherPair.bind((otherLeft, otherRight) -> bind((leftVal, rightVal) -> {
+			final CombinedLeft left = leftCombiner.apply(leftVal, otherLeft);
+			final CombinedRight right = rightCombiner.apply(rightVal, otherRight);
+
+			return new LazyPair<>(left, right);
+		}));
 	}
 
 	@Override
 	public LeftType getLeft() {
-		if(!leftMaterialized) {
+		if (!leftMaterialized) {
 			leftValue = leftSupplier.get();
 
 			leftMaterialized = true;
@@ -126,7 +129,7 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 
 	@Override
 	public RightType getRight() {
-		if(!rightMaterialized) {
+		if (!rightMaterialized) {
 			rightValue = rightSupplier.get();
 
 			rightMaterialized = true;
@@ -136,15 +139,18 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType> mapLeft(final Function<LeftType, NewLeft> mapper) {
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(final Function<LeftType, NewLeft> mapper) {
 		final Supplier<NewLeft> leftSupp = () -> {
-			if(leftMaterialized) return mapper.apply(leftValue);
+			if (leftMaterialized)
+				return mapper.apply(leftValue);
 
 			return mapper.apply(leftSupplier.get());
 		};
 
 		final Supplier<RightType> rightSupp = () -> {
-			if(rightMaterialized) return rightValue;
+			if (rightMaterialized)
+				return rightValue;
 
 			return rightSupplier.get();
 		};
@@ -153,15 +159,18 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight> mapRight(final Function<RightType, NewRight> mapper) {
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(final Function<RightType, NewRight> mapper) {
 		final Supplier<LeftType> leftSupp = () -> {
-			if(leftMaterialized) return leftValue;
+			if (leftMaterialized)
+				return leftValue;
 
 			return leftSupplier.get();
 		};
 
 		final Supplier<NewRight> rightSupp = () -> {
-			if(rightMaterialized) return mapper.apply(rightValue);
+			if (rightMaterialized)
+				return mapper.apply(rightValue);
 
 			return mapper.apply(rightSupplier.get());
 		};
@@ -170,14 +179,15 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(final BiFunction<LeftType, RightType, MergedType> merger) {
-		if(!leftMaterialized) {
+	public <MergedType> MergedType
+			merge(final BiFunction<LeftType, RightType, MergedType> merger) {
+		if (!leftMaterialized) {
 			leftValue = leftSupplier.get();
 
 			leftMaterialized = true;
 		}
 
-		if(!rightMaterialized) {
+		if (!rightMaterialized) {
 			rightValue = rightSupplier.get();
 
 			rightMaterialized = true;
@@ -191,13 +201,13 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 		String leftVal;
 		String rightVal;
 
-		if(leftMaterialized) {
+		if (leftMaterialized) {
 			leftVal = leftValue.toString();
 		} else {
 			leftVal = "(un-materialized)";
 		}
 
-		if(rightMaterialized) {
+		if (rightMaterialized) {
 			rightVal = rightValue.toString();
 		} else {
 			rightVal = "(un-materialized)";
@@ -221,26 +231,35 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof LazyPair<?, ?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof LazyPair<?, ?>))
+			return false;
 
 		final LazyPair<?, ?> other = (LazyPair<?, ?>) obj;
 
-		if(leftMaterialized != other.leftMaterialized) return false;
+		if (leftMaterialized != other.leftMaterialized)
+			return false;
 
-		if(leftMaterialized) {
-			if(leftValue == null) {
-				if(other.leftValue != null) return false;
-			} else if(!leftValue.equals(other.leftValue)) return false;
+		if (leftMaterialized) {
+			if (leftValue == null) {
+				if (other.leftValue != null)
+					return false;
+			} else if (!leftValue.equals(other.leftValue))
+				return false;
 		} else
 			return false;
 
-		if(rightMaterialized != other.rightMaterialized) return false;
-		if(rightMaterialized) {
-			if(rightValue == null) {
-				if(other.rightValue != null) return false;
-			} else if(!rightValue.equals(other.rightValue)) return false;
+		if (rightMaterialized != other.rightMaterialized)
+			return false;
+		if (rightMaterialized) {
+			if (rightValue == null) {
+				if (other.rightValue != null)
+					return false;
+			} else if (!rightValue.equals(other.rightValue))
+				return false;
 		} else
 			return false;
 
diff --git a/src/main/java/bjc/data/ListHolder.java b/src/main/java/bjc/data/ListHolder.java
index 077c0fb..ab3bfa8 100644
--- a/src/main/java/bjc/data/ListHolder.java
+++ b/src/main/java/bjc/data/ListHolder.java
@@ -13,7 +13,7 @@ import bjc.funcdata.IList;
  * @author ben
  *
  * @param <ContainedType>
- *        The type of contained value.
+ *                        The type of contained value.
  */
 public class ListHolder<ContainedType> implements IHolder<ContainedType> {
 	private IList<ContainedType> heldValues;
@@ -22,14 +22,14 @@ public class ListHolder<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new list holder.
 	 *
 	 * @param values
-	 *        The possible values for the computation.
+	 *               The possible values for the computation.
 	 */
 	@SafeVarargs
 	public ListHolder(final ContainedType... values) {
 		heldValues = new FunctionalList<>();
 
-		if(values != null) {
-			for(final ContainedType containedValue : values) {
+		if (values != null) {
+			for (final ContainedType containedValue : values) {
 				heldValues.add(containedValue);
 			}
 		}
@@ -41,35 +41,38 @@ public class ListHolder<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
 		final IList<IHolder<BoundType>> boundValues = heldValues.map(binder);
 
 		return new BoundListHolder<>(boundValues);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return val -> {
-			return new ListHolder<>(new FunctionalList<>(func.apply(val)));
-		};
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> new ListHolder<>(new FunctionalList<>(func.apply(val)));
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
 		final IList<MappedType> mappedValues = heldValues.map(mapper);
 
 		return new ListHolder<>(mappedValues);
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
 		heldValues = heldValues.map(transformer);
 
 		return this;
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
 		return unwrapper.apply(heldValues.randItem());
 	}
 
@@ -90,15 +93,20 @@ public class ListHolder<ContainedType> implements IHolder<ContainedType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof ListHolder<?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof ListHolder<?>))
+			return false;
 
 		final ListHolder<?> other = (ListHolder<?>) obj;
 
-		if(heldValues == null) {
-			if(other.heldValues != null) return false;
-		} else if(!heldValues.equals(other.heldValues)) return false;
+		if (heldValues == null) {
+			if (other.heldValues != null)
+				return false;
+		} else if (!heldValues.equals(other.heldValues))
+			return false;
 
 		return true;
 	}
diff --git a/src/main/java/bjc/data/OneWayToggle.java b/src/main/java/bjc/data/OneWayToggle.java
index a4557cd..c2e9e4b 100644
--- a/src/main/java/bjc/data/OneWayToggle.java
+++ b/src/main/java/bjc/data/OneWayToggle.java
@@ -3,7 +3,7 @@ package bjc.data;
 /**
  * A toggle that will only give the first value once, only yielding the second
  * value afterwards.
- * 
+ *
  * @author student
  *
  * @param <E>
@@ -17,11 +17,11 @@ public class OneWayToggle<E> implements Toggle<E> {
 
 	/**
 	 * Create a new one-way toggle
-	 * 
+	 *
 	 * @param first
-	 *            The value to offer first, and only once
+	 *               The value to offer first, and only once
 	 * @param second
-	 *            The value to offer second and repeatedly
+	 *               The value to offer second and repeatedly
 	 */
 	public OneWayToggle(E first, E second) {
 		this.first = first;
diff --git a/src/main/java/bjc/data/Option.java b/src/main/java/bjc/data/Option.java
index a180ef9..b5d6d5e 100644
--- a/src/main/java/bjc/data/Option.java
+++ b/src/main/java/bjc/data/Option.java
@@ -9,7 +9,7 @@ import java.util.function.UnaryOperator;
  * @author ben
  *
  * @param <ContainedType>
- *        The type of the value that may or may not be held.
+ *                        The type of the value that may or may not be held.
  */
 public class Option<ContainedType> implements IHolder<ContainedType> {
 	private ContainedType held;
@@ -18,36 +18,40 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new optional, using the given initial value.
 	 *
 	 * @param seed
-	 *        The initial value for the optional.
+	 *             The initial value for the optional.
 	 */
 	public Option(final ContainedType seed) {
 		held = seed;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
-		if(held == null) return new Option<>(null);
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+		if (held == null)
+			return new Option<>(null);
 
 		return binder.apply(held);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return val -> {
-			return new Option<>(func.apply(val));
-		};
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> new Option<>(func.apply(val));
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
-		if(held == null) return new Option<>(null);
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
+		if (held == null)
+			return new Option<>(null);
 
 		return new Option<>(mapper.apply(held));
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
-		if(held != null) {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
+		if (held != null) {
 			held = transformer.apply(held);
 		}
 
@@ -55,8 +59,10 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		if(held == null) return null;
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		if (held == null)
+			return null;
 
 		return unwrapper.apply(held);
 	}
@@ -78,15 +84,20 @@ public class Option<ContainedType> implements IHolder<ContainedType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Option<?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Option<?>))
+			return false;
 
 		final Option<?> other = (Option<?>) obj;
 
-		if(held == null) {
-			if(other.held != null) return false;
-		} else if(!held.equals(other.held)) return false;
+		if (held == null) {
+			if (other.held != null)
+				return false;
+		} else if (!held.equals(other.held))
+			return false;
 
 		return true;
 	}
diff --git a/src/main/java/bjc/data/Pair.java b/src/main/java/bjc/data/Pair.java
index 3c1b7b5..610e89c 100644
--- a/src/main/java/bjc/data/Pair.java
+++ b/src/main/java/bjc/data/Pair.java
@@ -9,10 +9,10 @@ import java.util.function.Function;
  * @author ben
  *
  * @param <LeftType>
- *        The type of the left value.
+ *                    The type of the left value.
  *
  * @param <RightType>
- *        The type of the right value.
+ *                    The type of the right value.
  */
 public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	/* The left value. */
@@ -29,10 +29,10 @@ public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	 * Create a new pair with both sides set to the specified values.
 	 *
 	 * @param left
-	 *        The value of the left side.
+	 *              The value of the left side.
 	 *
 	 * @param right
-	 *        The value of the right side.
+	 *              The value of the right side.
 	 */
 	public Pair(final LeftType left, final RightType right) {
 		leftValue = left;
@@ -42,15 +42,17 @@ public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
 			final BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
-		if(binder == null) throw new NullPointerException("Binder must not be null.");
+		if (binder == null)
+			throw new NullPointerException("Binder must not be null.");
 
 		return binder.apply(leftValue, rightValue);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
-			final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
-		if(leftBinder == null) throw new NullPointerException("Binder must not be null");
+	public <BoundLeft> IPair<BoundLeft, RightType>
+			bindLeft(final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+		if (leftBinder == null)
+			throw new NullPointerException("Binder must not be null");
 
 		return leftBinder.apply(leftValue);
 	}
@@ -58,16 +60,19 @@ public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	@Override
 	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
 			final Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
-		if(rightBinder == null) throw new NullPointerException("Binder must not be null");
+		if (rightBinder == null)
+			throw new NullPointerException("Binder must not be null");
 
 		return rightBinder.apply(rightValue);
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			final IPair<OtherLeft, OtherRight> otherPair,
-			final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
-			final BiFunction<RightType, OtherRight, CombinedRight> rightCombiner) {
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(final IPair<OtherLeft, OtherRight> otherPair,
+					final BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+					final BiFunction<RightType, OtherRight,
+							CombinedRight> rightCombiner) {
 		return otherPair.bind((otherLeft, otherRight) -> {
 			final CombinedLeft left = leftCombiner.apply(leftValue, otherLeft);
 			final CombinedRight right = rightCombiner.apply(rightValue, otherRight);
@@ -77,35 +82,44 @@ public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType> mapLeft(final Function<LeftType, NewLeft> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewLeft> IPair<NewLeft, RightType>
+			mapLeft(final Function<LeftType, NewLeft> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
 		return new Pair<>(mapper.apply(leftValue), rightValue);
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight> mapRight(final Function<RightType, NewRight> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewRight> IPair<LeftType, NewRight>
+			mapRight(final Function<RightType, NewRight> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
 		return new Pair<>(leftValue, mapper.apply(rightValue));
 	}
 
 	@Override
-	public <MergedType> MergedType merge(final BiFunction<LeftType, RightType, MergedType> merger) {
-		if(merger == null) throw new NullPointerException("Merger must not be null");
+	public <MergedType> MergedType
+			merge(final BiFunction<LeftType, RightType, MergedType> merger) {
+		if (merger == null)
+			throw new NullPointerException("Merger must not be null");
 
 		return merger.apply(leftValue, rightValue);
 	}
 
 	@Override
 	public String toString() {
-		return String.format("Pair [leftValue='%s', rightValue='%s']", leftValue, rightValue);
+		return String.format("Pair [leftValue='%s', rightValue='%s']", leftValue,
+				rightValue);
 	}
 
+	@Override
 	public LeftType getLeft() {
 		return leftValue;
 	}
 
+	@Override
 	public RightType getRight() {
 		return rightValue;
 	}
@@ -123,19 +137,26 @@ public class Pair<LeftType, RightType> implements IPair<LeftType, RightType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Pair<?, ?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Pair<?, ?>))
+			return false;
 
 		final Pair<?, ?> other = (Pair<?, ?>) obj;
 
-		if(leftValue == null) {
-			if(other.leftValue != null) return false;
-		} else if(!leftValue.equals(other.leftValue)) return false;
-
-		if(rightValue == null) {
-			if(other.rightValue != null) return false;
-		} else if(!rightValue.equals(other.rightValue)) return false;
+		if (leftValue == null) {
+			if (other.leftValue != null)
+				return false;
+		} else if (!leftValue.equals(other.leftValue))
+			return false;
+
+		if (rightValue == null) {
+			if (other.rightValue != null)
+				return false;
+		} else if (!rightValue.equals(other.rightValue))
+			return false;
 
 		return true;
 	}
diff --git a/src/main/java/bjc/data/QueuedIterator.java b/src/main/java/bjc/data/QueuedIterator.java
index ebacb52..f10014e 100644
--- a/src/main/java/bjc/data/QueuedIterator.java
+++ b/src/main/java/bjc/data/QueuedIterator.java
@@ -6,10 +6,11 @@ import java.util.Iterator;
 
 /**
  * An iterator that supports queuing elements after/before the current iterator;
- * 
+ *
  * @author bjculkin
  *
- * @param <E> The type of element this iterator iterates over
+ * @param <E>
+ *            The type of element this iterator iterates over
  */
 public class QueuedIterator<E> implements Iterator<E> {
 	private Iterator<E> cur;
@@ -18,7 +19,7 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Static method for constructing iterators.
-	 * 
+	 *
 	 * @return A queued iterator.
 	 */
 	public static <E> QueuedIterator<E> queued() {
@@ -27,9 +28,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Static method for constructing iterators.
-	 * 
+	 *
 	 * @param vals
-	 * 		The values to iterate over.
+	 *             The values to iterate over.
 	 *
 	 * @return A queued iterator.
 	 */
@@ -40,9 +41,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Static method for constructing iterators.
-	 * 
+	 *
 	 * @param itrs
-	 * 		The iterators to use.
+	 *             The iterators to use.
 	 *
 	 * @return A queued iterator over the provided iterators.
 	 */
@@ -53,9 +54,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Static method for constructing iterators.
-	 * 
+	 *
 	 * @param itrs
-	 * 		The iterables to use.
+	 *             The iterables to use.
 	 *
 	 * @return A queued iterator over the provided iterables.
 	 */
@@ -73,9 +74,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Create a new queued iterator with a set of initial sources.
-	 * 
+	 *
 	 * @param inits
-	 *                The set of initial iterators to use.
+	 *              The set of initial iterators to use.
 	 */
 	@SafeVarargs
 	public QueuedIterator(Iterator<E>... inits) {
@@ -88,9 +89,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Create a new queued iterator with a set of initial sources.
-	 * 
+	 *
 	 * @param inits
-	 *                The set of initial iterables to use.
+	 *              The set of initial iterables to use.
 	 */
 	@SafeVarargs
 	public QueuedIterator(Iterable<E>... inits) {
@@ -103,9 +104,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Create a new queued iterator with a set of initial values.
-	 * 
+	 *
 	 * @param vals
-	 * 		The set of initial values to use.
+	 *             The set of initial values to use.
 	 */
 	@SafeVarargs
 	public QueuedIterator(E... vals) {
@@ -114,9 +115,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new iterator who we will iterate through first.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterator to go through first.
+	 *            The iterator to go through first.
 	 */
 	public void before(Iterator<E> itr) {
 		pending.push(cur);
@@ -126,19 +127,19 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new iterable who we will iterate through first.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterable to go through first.
+	 *            The iterable to go through first.
 	 */
 	public void before(Iterable<E> itr) {
 		before(itr.iterator());
 	}
-	
+
 	/**
 	 * Add a new set of values who we will iterate through first.
-	 * 
+	 *
 	 * @param vals
-	 * 		Values to iterate over first.
+	 *             Values to iterate over first.
 	 */
 	public void before(@SuppressWarnings("unchecked") E... vals) {
 		before(new ArrayIterator<>(vals));
@@ -146,9 +147,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new iterator who we will iterate through next.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterator to go through next.
+	 *            The iterator to go through next.
 	 */
 	public void after(Iterator<E> itr) {
 		pending.push(itr);
@@ -156,9 +157,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new iterable who we will iterate through next.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterable to go through next.
+	 *            The iterable to go through next.
 	 */
 	public void after(Iterable<E> itr) {
 		after(itr.iterator());
@@ -166,19 +167,19 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new set of values who we will iterate through next.
-	 * 
+	 *
 	 * @param vals
-	 * 		The values to iterate over next.
+	 *             The values to iterate over next.
 	 */
 	public void after(@SuppressWarnings("unchecked") E... vals) {
 		after(new ArrayIterator<>(vals));
 	}
-	
+
 	/**
 	 * Add a new iterator who we will iterate through last.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterator to go through last.
+	 *            The iterator to go through last.
 	 */
 	public void last(Iterator<E> itr) {
 		pending.add(itr);
@@ -186,9 +187,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new iterable who we will iterate through last.
-	 * 
+	 *
 	 * @param itr
-	 *                The iterable to go through last.
+	 *            The iterable to go through last.
 	 */
 	public void last(Iterable<E> itr) {
 		last(itr.iterator());
@@ -196,9 +197,9 @@ public class QueuedIterator<E> implements Iterator<E> {
 
 	/**
 	 * Add a new set of values who we will iterate through last.
-	 * 
+	 *
 	 * @param vals
-	 * 	The values we will iterate over.
+	 *             The values we will iterate over.
 	 */
 	public void last(@SuppressWarnings("unchecked") E... vals) {
 		last(new ArrayIterator<>(vals));
@@ -207,7 +208,8 @@ public class QueuedIterator<E> implements Iterator<E> {
 	@Override
 	public boolean hasNext() {
 		while (cur == null || !cur.hasNext()) {
-			if (pending.isEmpty()) return false;
+			if (pending.isEmpty())
+				return false;
 
 			cur = pending.pop();
 		}
@@ -218,7 +220,8 @@ public class QueuedIterator<E> implements Iterator<E> {
 	@Override
 	public E next() {
 		while (cur == null || !cur.hasNext()) {
-			if (pending.isEmpty()) return null;
+			if (pending.isEmpty())
+				return null;
 
 			cur = pending.pop();
 		}
diff --git a/src/main/java/bjc/data/SingleIterator.java b/src/main/java/bjc/data/SingleIterator.java
index 3144447..1598774 100644
--- a/src/main/java/bjc/data/SingleIterator.java
+++ b/src/main/java/bjc/data/SingleIterator.java
@@ -8,7 +8,7 @@ import java.util.Iterator;
  * @author EVE
  *
  * @param <T>
- *        The type of the item.
+ *            The type of the item.
  */
 public class SingleIterator<T> implements Iterator<T> {
 	/* The item being held. */
@@ -20,7 +20,7 @@ public class SingleIterator<T> implements Iterator<T> {
 	 * Create a iterator that yields a single item.
 	 *
 	 * @param item
-	 *        The item to yield.
+	 *             The item to yield.
 	 */
 	public SingleIterator(final T item) {
 		itm = item;
diff --git a/src/main/java/bjc/data/SingleSupplier.java b/src/main/java/bjc/data/SingleSupplier.java
index bc1fbc4..010b06e 100644
--- a/src/main/java/bjc/data/SingleSupplier.java
+++ b/src/main/java/bjc/data/SingleSupplier.java
@@ -10,7 +10,7 @@ import java.util.function.Supplier;
  * @author ben
  *
  * @param <T>
- *        The supplied type
+ *            The supplied type
  */
 public class SingleSupplier<T> implements Supplier<T> {
 	/* The next supplier ID. */
@@ -26,8 +26,8 @@ public class SingleSupplier<T> implements Supplier<T> {
 	 * The place where the supplier was instantiated.
 	 *
 	 * @NOTE This is both slow to create, and generally bad practice to keep
-	 * exceptions around without throwing them. However, it is very useful
-	 * to find where the first instantiation was.
+	 * exceptions around without throwing them. However, it is very useful to find
+	 * where the first instantiation was.
 	 */
 	private Exception instSite;
 
@@ -35,7 +35,7 @@ public class SingleSupplier<T> implements Supplier<T> {
 	 * Create a new single supplier from an existing value.
 	 *
 	 * @param supp
-	 *        The supplier to give a single value from.
+	 *             The supplier to give a single value from.
 	 */
 	public SingleSupplier(final Supplier<T> supp) {
 		source = supp;
@@ -47,9 +47,10 @@ public class SingleSupplier<T> implements Supplier<T> {
 
 	@Override
 	public T get() {
-		if(gotten == true) {
+		if (gotten == true) {
 			final String msg = String.format(
-					"Attempted to retrieve value more than once from single supplier #%d", id);
+					"Attempted to retrieve value more than once from single supplier #%d",
+					id);
 
 			final IllegalStateException isex = new IllegalStateException(msg);
 
@@ -62,7 +63,7 @@ public class SingleSupplier<T> implements Supplier<T> {
 
 		try {
 			throw new IllegalStateException("Previous instantiation here.");
-		} catch(final IllegalStateException isex) {
+		} catch (final IllegalStateException isex) {
 			instSite = isex;
 		}
 
@@ -71,6 +72,7 @@ public class SingleSupplier<T> implements Supplier<T> {
 
 	@Override
 	public String toString() {
-		return String.format("SingleSupplier [source='%s', gotten=%s, id=%s]", source, gotten, id);
+		return String.format("SingleSupplier [source='%s', gotten=%s, id=%s]", source,
+				gotten, id);
 	}
 }
diff --git a/src/main/java/bjc/data/Toggle.java b/src/main/java/bjc/data/Toggle.java
index 14c77d3..17c5a8e 100644
--- a/src/main/java/bjc/data/Toggle.java
+++ b/src/main/java/bjc/data/Toggle.java
@@ -6,12 +6,12 @@ package bjc.data;
  * @author EVE
  *
  * @param <E>
- *        The value stored in the toggle.
+ *            The value stored in the toggle.
  */
 public interface Toggle<E> {
 	/**
-	 * Retrieve the currently-aligned value of this toggle, and swap the
-	 * value to the new one.
+	 * Retrieve the currently-aligned value of this toggle, and swap the value to
+	 * the new one.
 	 *
 	 * @return The previously-aligned value.
 	 */
@@ -28,7 +28,7 @@ public interface Toggle<E> {
 	 * Change the alignment of the toggle.
 	 *
 	 * @param isLeft
-	 *        Whether the toggle should be left-aligned or not.
+	 *               Whether the toggle should be left-aligned or not.
 	 */
 	void set(boolean isLeft);
 }
diff --git a/src/main/java/bjc/data/TopDownTransformIterator.java b/src/main/java/bjc/data/TopDownTransformIterator.java
index 66faafe..3b4b997 100644
--- a/src/main/java/bjc/data/TopDownTransformIterator.java
+++ b/src/main/java/bjc/data/TopDownTransformIterator.java
@@ -12,30 +12,31 @@ import java.util.function.Function;
 
 /*
  * @TODO 10/11/17 Ben Culkin :TopDownStep
- * 
+ *
  * 	Figure out what is broken with this, and fix it so that step-wise
  * 	iteration works correctly.
  */
 
 /**
  * An iterative top-down transform of a tree.
- * 
+ *
  * @author EVE
  *
  * @param <ContainedType>
- *            The type of the nodes in the tree.
+ *                        The type of the nodes in the tree.
  */
-public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<ContainedType>> {
+public class TopDownTransformIterator<ContainedType>
+		implements Iterator<ITree<ContainedType>> {
 	/**
 	 * Alias type for a tree transformation.
-	 * 
+	 *
 	 * @author student
 	 *
 	 * @param <ContainedType>
-	 *            The type contained in the tree.
+	 *                        The type contained in the tree.
 	 */
-	public interface TreeTransform<ContainedType>
-			extends BiFunction<ITree<ContainedType>, Consumer<Iterator<ITree<ContainedType>>>, ITree<ContainedType>> {
+	public interface TreeTransform<ContainedType> extends BiFunction<ITree<ContainedType>,
+			Consumer<Iterator<ITree<ContainedType>>>, ITree<ContainedType>> {
 		// Alias type; no body is needed
 	}
 
@@ -64,32 +65,34 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 
 	/**
 	 * Create a new tree iterator.
-	 * 
+	 *
 	 * @param pickr
-	 *            The function to use to pick how to process nodes.
+	 *                 The function to use to pick how to process nodes.
 	 * @param transfrm
-	 *            The transform to apply to the nodes.
+	 *                 The transform to apply to the nodes.
 	 * @param tree
-	 *            The tree to transform.
+	 *                 The tree to transform.
 	 */
-	public TopDownTransformIterator(final Function<ContainedType, TopDownTransformResult> pickr,
-			final TreeTransform<ContainedType> transfrm, final ITree<ContainedType> tree) {
+	public TopDownTransformIterator(
+			final Function<ContainedType, TopDownTransformResult> pickr,
+			final TreeTransform<ContainedType> transfrm,
+			final ITree<ContainedType> tree) {
 		preParent = tree;
 
-		preChildren  = new LinkedList<>();
+		preChildren = new LinkedList<>();
 		postChildren = new LinkedList<>();
-		toYield      = new LinkedList<>();
+		toYield = new LinkedList<>();
 
-		picker    = pickr;
+		picker = pickr;
 		transform = transfrm;
 
-		done    = false;
+		done = false;
 		initial = true;
 	}
 
 	/**
 	 * Add a set of nodes to yield.
-	 * 
+	 *
 	 * @param src
 	 *            The nodes to yield.
 	 */
@@ -108,10 +111,10 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 
 	/**
 	 * Get the next yielded value.
-	 * 
+	 *
 	 * @param val
 	 *            The sentinel value to yield.
-	 * 
+	 *
 	 * @return The next yielded value.
 	 */
 	public ITree<ContainedType> flushYields(final ITree<ContainedType> val) {
@@ -158,7 +161,7 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 			if (yeld != null)
 				return yeld;
 		}
-		
+
 		if (initial) {
 			/*
 			 * Get the way we are transforming.
@@ -200,9 +203,11 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 				}
 
 				done = true;
-				return flushYields(transform.apply(new Tree<>(preParent.getHead()), this::addYield));
+				return flushYields(
+						transform.apply(new Tree<>(preParent.getHead()), this::addYield));
 			case PULLUP:
-				final ITree<ContainedType> intRes = transform.apply(preParent, this::addYield);
+				final ITree<ContainedType> intRes
+						= transform.apply(preParent, this::addYield);
 
 				postParent = new Tree<>(intRes.getHead());
 
@@ -228,10 +233,11 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 
 		if (curChild == null || !curChild.hasNext()) {
 			if (preChildren.size() != 0) {
-				curChild = new TopDownTransformIterator<>(picker, transform, preChildren.pop());
+				curChild = new TopDownTransformIterator<>(picker, transform,
+						preChildren.pop());
 
 				final ITree<ContainedType> res = curChild.next();
-				//System.out.println("\t\tTRACE: adding node " + res + " to children");
+				// System.out.println("\t\tTRACE: adding node " + res + " to children");
 				postChildren.add(res);
 
 				return flushYields(res);
@@ -242,7 +248,8 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 			if (postParent == null) {
 				res = new Tree<>(preParent.getHead());
 
-				//System.out.println("\t\tTRACE: adding nodes " + postChildren + " to " + res);
+				// System.out.println("\t\tTRACE: adding nodes " + postChildren + " to " +
+				// res);
 
 				for (final ITree<ContainedType> child : postChildren) {
 					res.addChild(child);
@@ -253,7 +260,8 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 			} else {
 				res = postParent;
 
-				//System.out.println("\t\tTRACE: adding nodes " + postChildren + " to " + res);
+				// System.out.println("\t\tTRACE: adding nodes " + postChildren + " to " +
+				// res);
 				for (final ITree<ContainedType> child : postChildren) {
 					res.addChild(child);
 				}
@@ -264,7 +272,7 @@ public class TopDownTransformIterator<ContainedType> implements Iterator<ITree<C
 		}
 
 		final ITree<ContainedType> res = curChild.next();
-		//System.out.println("\t\tTRACE: adding node " + res + " to children");
+		// System.out.println("\t\tTRACE: adding node " + res + " to children");
 		postChildren.add(res);
 
 		return flushYields(res);
diff --git a/src/main/java/bjc/data/TransformIterator.java b/src/main/java/bjc/data/TransformIterator.java
index 0fc127a..29f91e2 100644
--- a/src/main/java/bjc/data/TransformIterator.java
+++ b/src/main/java/bjc/data/TransformIterator.java
@@ -9,10 +9,10 @@ import java.util.function.Function;
  * @author EVE
  *
  * @param <S>
- *        The source iterator type.
+ *            The source iterator type.
  *
  * @param <D>
- *        The destination iterator type.
+ *            The destination iterator type.
  */
 public class TransformIterator<S, D> implements Iterator<D> {
 	/* Our source of values. */
@@ -24,10 +24,10 @@ public class TransformIterator<S, D> implements Iterator<D> {
 	 * Create a new transform iterator.
 	 *
 	 * @param source
-	 *        The source iterator to use.
+	 *                  The source iterator to use.
 	 *
 	 * @param transform
-	 *        The transform to apply.
+	 *                  The transform to apply.
 	 */
 	public TransformIterator(final Iterator<S> source, final Function<S, D> transform) {
 		this.source = source;
diff --git a/src/main/java/bjc/data/Tree.java b/src/main/java/bjc/data/Tree.java
index d9ccb34..27dcf11 100644
--- a/src/main/java/bjc/data/Tree.java
+++ b/src/main/java/bjc/data/Tree.java
@@ -16,7 +16,7 @@ import bjc.funcdata.bst.TreeLinearizationMethod;
  * @author ben
  *
  * @param <ContainedType>
- *        The type contained in the tree.
+ *                        The type contained in the tree.
  */
 public class Tree<ContainedType> implements ITree<ContainedType> {
 	/* The data/label for this node. */
@@ -27,10 +27,9 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	/* Whether this node has children. */
 	/*
-	 * @NOTE Why have both this boolean and childCount? Why not just do a
-	 * childCount == 0 whenever you'd check hasChildren?
-	 * 	- Because hasChildren is set once and not reset, and really what
-	 * 		it indicates is that children has been allocated.
+	 * @NOTE Why have both this boolean and childCount? Why not just do a childCount
+	 * == 0 whenever you'd check hasChildren? - Because hasChildren is set once and
+	 * not reset, and really what it indicates is that children has been allocated.
 	 */
 	private boolean hasChildren;
 	/* The number of children this node has. */
@@ -52,7 +51,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	 * Create a new leaf node in a tree.
 	 *
 	 * @param leaf
-	 *        The data to store as a leaf node.
+	 *             The data to store as a leaf node.
 	 */
 	public Tree(final ContainedType leaf) {
 		data = leaf;
@@ -66,10 +65,10 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	 * Create a new tree node with the specified children.
 	 *
 	 * @param leaf
-	 *        The data to hold in this node.
+	 *                The data to hold in this node.
 	 *
 	 * @param childrn
-	 *        A list of children for this node.
+	 *                A list of children for this node.
 	 */
 	public Tree(final ContainedType leaf, final IList<ITree<ContainedType>> childrn) {
 		this(leaf);
@@ -85,10 +84,10 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	 * Create a new tree node with the specified children.
 	 *
 	 * @param leaf
-	 *        The data to hold in this node.
+	 *                The data to hold in this node.
 	 *
 	 * @param childrn
-	 *        A list of children for this node.
+	 *                A list of children for this node.
 	 */
 	@SafeVarargs
 	public Tree(final ContainedType leaf, final ITree<ContainedType>... childrn) {
@@ -100,7 +99,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 		children = new FunctionalList<>();
 
-		for(final ITree<ContainedType> child : childrn) {
+		for (final ITree<ContainedType> child : childrn) {
 			children.add(child);
 
 			childCount++;
@@ -114,7 +113,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public void addChild(final ITree<ContainedType> child) {
-		if(hasChildren == false) {
+		if (hasChildren == false) {
 			hasChildren = true;
 
 			children = new FunctionalList<>();
@@ -127,7 +126,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public void prependChild(final ITree<ContainedType> child) {
-		if(hasChildren == false) {
+		if (hasChildren == false) {
 			hasChildren = true;
 
 			children = new FunctionalList<>();
@@ -140,7 +139,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public void doForChildren(final Consumer<ITree<ContainedType>> action) {
-		if(childCount > 0) {
+		if (childCount > 0) {
 			children.forEach(action);
 		}
 	}
@@ -152,23 +151,25 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public int revFind(final Predicate<ITree<ContainedType>> childPred) {
-		if(childCount == 0) {
+		if (childCount == 0) {
 			return -1;
 		}
 
-		for(int i = childCount - 1; i >= 0; i--) {
-			if(childPred.test(getChild(i))) return i;
+		for (int i = childCount - 1; i >= 0; i--) {
+			if (childPred.test(getChild(i)))
+				return i;
 		}
 
 		return -1;
 	}
 
 	@Override
-	public void traverse(final TreeLinearizationMethod linearizationMethod, final Consumer<ContainedType> action) {
-		if(hasChildren) {
-			switch(linearizationMethod) {
+	public void traverse(final TreeLinearizationMethod linearizationMethod,
+			final Consumer<ContainedType> action) {
+		if (hasChildren) {
+			switch (linearizationMethod) {
 			case INORDER:
-				if(childCount != 2) {
+				if (childCount != 2) {
 					final String msg = "Can only do in-order traversal for binary trees.";
 
 					throw new IllegalArgumentException(msg);
@@ -181,14 +182,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 				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;
@@ -200,19 +201,21 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	}
 
 	@Override
-	public <NewType, ReturnedType> ReturnedType collapse(final Function<ContainedType, NewType> leafTransform,
+	public <NewType, ReturnedType> ReturnedType collapse(
+			final Function<ContainedType, NewType> leafTransform,
 			final BiFunction<ContainedType, IList<NewType>, NewType> nodeCollapser,
 			final Function<NewType, ReturnedType> resultTransformer) {
 		return resultTransformer.apply(internalCollapse(leafTransform, nodeCollapser));
 	}
 
 	@Override
-	public ITree<ContainedType> flatMapTree(final Function<ContainedType, ITree<ContainedType>> mapper) {
-		if(hasChildren) {
+	public ITree<ContainedType>
+			flatMapTree(final Function<ContainedType, ITree<ContainedType>> mapper) {
+		if (hasChildren) {
 			final ITree<ContainedType> flatMappedData = mapper.apply(data);
 
-			final IList<ITree<ContainedType>> mappedChildren = children
-					.map(child -> child.flatMapTree(mapper));
+			final IList<ITree<ContainedType>> mappedChildren
+					= children.map(child -> child.flatMapTree(mapper));
 
 			mappedChildren.forEach(flatMappedData::addChild);
 
@@ -225,13 +228,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	/*
 	 * Do a collapse of this tree.
 	 *
-	 * @NOTE Why is this protected? I can't see any good reason someone'd
-	 * want to override it.
+	 * @NOTE Why is this protected? I can't see any good reason someone'd want to
+	 * override it.
 	 */
 
-	protected <NewType> NewType internalCollapse(final Function<ContainedType, NewType> leafTransform,
+	protected <NewType> NewType internalCollapse(
+			final Function<ContainedType, NewType> leafTransform,
 			final BiFunction<ContainedType, IList<NewType>, NewType> nodeCollapser) {
-		if(hasChildren) {
+		if (hasChildren) {
 			final IList<NewType> collapsedChildren = children.map(child -> {
 				final NewType collapsed = child.collapse(leafTransform, nodeCollapser,
 						subTreeVal -> subTreeVal);
@@ -245,9 +249,10 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 		return leafTransform.apply(data);
 	}
 
-	protected void internalToString(final StringBuilder builder, final int indentLevel, final boolean initial) {
-		if(!initial) {
-			for(int i = 0; i < indentLevel; i++) {
+	protected void internalToString(final StringBuilder builder, final int indentLevel,
+			final boolean initial) {
+		if (!initial) {
+			for (int i = 0; i < indentLevel; i++) {
 				builder.append(">\t");
 			}
 		}
@@ -258,14 +263,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 		builder.append(data == null ? "(null)" : data.toString());
 		builder.append("\n");
 
-		if(hasChildren) {
+		if (hasChildren) {
 			children.forEach(child -> {
-				if(child instanceof Tree<?>) {
+				if (child instanceof Tree<?>) {
 					final Tree<ContainedType> kid = (Tree<ContainedType>) child;
 
 					kid.internalToString(builder, indentLevel + 1, false);
 				} else {
-					for(int i = 0; i < indentLevel + 1; i++) {
+					for (int i = 0; i < indentLevel + 1; i++) {
 						builder.append(">\t");
 					}
 
@@ -278,12 +283,11 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	}
 
 	@Override
-	public <MappedType> ITree<MappedType> rebuildTree(final Function<ContainedType, MappedType> leafTransformer,
+	public <MappedType> ITree<MappedType> rebuildTree(
+			final Function<ContainedType, MappedType> leafTransformer,
 			final Function<ContainedType, MappedType> operatorTransformer) {
-		if(hasChildren) {
-			final IList<ITree<MappedType>> mappedChildren = children.map(child -> {
-				return child.rebuildTree(leafTransformer, operatorTransformer);
-			});
+		if (hasChildren) {
+			final IList<ITree<MappedType>> mappedChildren = children.map(child -> child.rebuildTree(leafTransformer, operatorTransformer));
 
 			final MappedType mapData = operatorTransformer.apply(data);
 			return new Tree<>(mapData, mappedChildren);
@@ -295,7 +299,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	@Override
 	public void selectiveTransform(final Predicate<ContainedType> nodePicker,
 			final UnaryOperator<ContainedType> transformer) {
-		if(hasChildren) {
+		if (hasChildren) {
 			children.forEach(child -> child.selectiveTransform(nodePicker, transformer));
 		} else {
 			data = transformer.apply(data);
@@ -308,14 +312,14 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			final UnaryOperator<ITree<ContainedType>> transformer) {
 		final TopDownTransformResult transformResult = transformPicker.apply(data);
 
-		switch(transformResult) {
+		switch (transformResult) {
 		case PASSTHROUGH:
 			ITree<ContainedType> result = new Tree<>(data);
 
-			if(hasChildren) {
+			if (hasChildren) {
 				children.forEach(child -> {
-					final ITree<ContainedType> kid = child.topDownTransform(transformPicker,
-							transformer);
+					final ITree<ContainedType> kid
+							= child.topDownTransform(transformPicker, transformer);
 
 					result.addChild(kid);
 				});
@@ -331,10 +335,10 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 		case PUSHDOWN:
 			result = new Tree<>(data);
 
-			if(hasChildren) {
+			if (hasChildren) {
 				children.forEach(child -> {
-					final ITree<ContainedType> kid = child.topDownTransform(transformPicker,
-							transformer);
+					final ITree<ContainedType> kid
+							= child.topDownTransform(transformPicker, transformer);
 
 					result.addChild(kid);
 				});
@@ -347,14 +351,16 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 			result = new Tree<>(intermediateResult.getHead());
 
 			intermediateResult.doForChildren(child -> {
-				final ITree<ContainedType> kid = child.topDownTransform(transformPicker, transformer);
+				final ITree<ContainedType> kid
+						= child.topDownTransform(transformPicker, transformer);
 
 				result.addChild(kid);
 			});
 
 			return result;
 		default:
-			final String msg = String.format("Recieved unknown transform result type %s", transformResult);
+			final String msg = String.format("Recieved unknown transform result type %s",
+					transformResult);
 
 			throw new IllegalArgumentException(msg);
 		}
@@ -363,7 +369,7 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	@Override
 	public <TransformedType> TransformedType transformChild(final int childNo,
 			final Function<ITree<ContainedType>, TransformedType> transformer) {
-		if(childNo < 0 || childNo > childCount - 1) {
+		if (childNo < 0 || childNo > childCount - 1) {
 			final String msg = String.format("Child index #%d is invalid", childNo);
 
 			throw new IllegalArgumentException(msg);
@@ -375,8 +381,8 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 	}
 
 	@Override
-	public <TransformedType> TransformedType transformHead(
-			final Function<ContainedType, TransformedType> transformer) {
+	public <TransformedType> TransformedType
+			transformHead(final Function<ContainedType, TransformedType> transformer) {
 		return transformer.apply(data);
 	}
 
@@ -411,21 +417,29 @@ public class Tree<ContainedType> implements ITree<ContainedType> {
 
 	@Override
 	public boolean equals(final Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Tree<?>)) return false;
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (!(obj instanceof Tree<?>))
+			return false;
 
 		final Tree<?> other = (Tree<?>) obj;
 
-		if(data == null) {
-			if(other.data != null) return false;
-		} else if(!data.equals(other.data)) return false;
+		if (data == null) {
+			if (other.data != null)
+				return false;
+		} else if (!data.equals(other.data))
+			return false;
 
-		if(childCount != other.childCount) return false;
+		if (childCount != other.childCount)
+			return false;
 
-		if(children == null) {
-			if(other.children != null) return false;
-		} else if(!children.equals(other.children)) return false;
+		if (children == null) {
+			if (other.children != null)
+				return false;
+		} else if (!children.equals(other.children))
+			return false;
 
 		return true;
 	}
diff --git a/src/main/java/bjc/data/ValueToggle.java b/src/main/java/bjc/data/ValueToggle.java
index e79169f..041a2d5 100644
--- a/src/main/java/bjc/data/ValueToggle.java
+++ b/src/main/java/bjc/data/ValueToggle.java
@@ -6,7 +6,7 @@ package bjc.data;
  * @author EVE
  *
  * @param <E>
- *        The type of value to toggle between.
+ *            The type of value to toggle between.
  */
 public class ValueToggle<E> implements Toggle<E> {
 	/* Our left value. */
@@ -22,10 +22,10 @@ public class ValueToggle<E> implements Toggle<E> {
 	 * All toggles start right-aligned.
 	 *
 	 * @param left
-	 *        The value when the toggle is left-aligned.
+	 *              The value when the toggle is left-aligned.
 	 *
 	 * @param right
-	 *        The value when the toggle is right-aligned.
+	 *              The value when the toggle is right-aligned.
 	 */
 	public ValueToggle(final E left, final E right) {
 		lft = left;
@@ -37,7 +37,7 @@ public class ValueToggle<E> implements Toggle<E> {
 
 	@Override
 	public E get() {
-		if(alignment.get()) {
+		if (alignment.get()) {
 			return lft;
 		}
 
@@ -46,7 +46,7 @@ public class ValueToggle<E> implements Toggle<E> {
 
 	@Override
 	public E peek() {
-		if(alignment.peek()) {
+		if (alignment.peek()) {
 			return lft;
 		}
 
diff --git a/src/main/java/bjc/data/internals/BoundLazy.java b/src/main/java/bjc/data/internals/BoundLazy.java
index 728af8e..9c984eb 100644
--- a/src/main/java/bjc/data/internals/BoundLazy.java
+++ b/src/main/java/bjc/data/internals/BoundLazy.java
@@ -15,7 +15,8 @@ import bjc.funcdata.IList;
  * @author Ben Culkin
  */
 @SuppressWarnings("javadoc")
-public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundContainedType> {
+public class BoundLazy<OldType, BoundContainedType>
+		implements IHolder<BoundContainedType> {
 	/* The old value. */
 	private final Supplier<IHolder<OldType>> oldSupplier;
 
@@ -29,16 +30,17 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 	private boolean holderBound;
 
 	/* Transformations currently pending on the bound value. */
-	private final IList<UnaryOperator<BoundContainedType>> actions = new FunctionalList<>();
+	private final IList<UnaryOperator<BoundContainedType>> actions
+			= new FunctionalList<>();
 
 	/**
 	 * Create a new bound lazy value.
 	 *
 	 * @param supp
-	 *        The supplier of the old value.
+	 *               The supplier of the old value.
 	 *
 	 * @param binder
-	 *        The function to use to bind the old value to the new one.
+	 *               The function to use to bind the old value to the new one.
 	 */
 	public BoundLazy(final Supplier<IHolder<OldType>> supp,
 			final Function<OldType, IHolder<BoundContainedType>> binder) {
@@ -47,11 +49,14 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<BoundContainedType, IHolder<BoundType>> bindr) {
-		if(bindr == null) throw new NullPointerException("Binder must not be null");
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<BoundContainedType, IHolder<BoundType>> bindr) {
+		if (bindr == null)
+			throw new NullPointerException("Binder must not be null");
 
 		/* Prepare a list of pending actions. */
-		final IList<UnaryOperator<BoundContainedType>> pendingActions = new FunctionalList<>();
+		final IList<UnaryOperator<BoundContainedType>> pendingActions
+				= new FunctionalList<>();
 		actions.forEach(pendingActions::add);
 
 		/* Create the new supplier of a value. */
@@ -59,35 +64,37 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 			IHolder<BoundContainedType> oldHolder = boundHolder;
 
 			/* Bind the value if it hasn't been bound before. */
-			if(!holderBound) {
+			if (!holderBound) {
 				oldHolder = oldSupplier.get().unwrap(binder);
 			}
 
 			/* Apply all the pending actions. */
-			return pendingActions.reduceAux(oldHolder, (action, state) -> {
-				return state.transform(action);
-			}, (value) -> value);
+			return pendingActions.reduceAux(oldHolder, (action, state) -> state.transform(action), value -> value);
 		};
 
 		return new BoundLazy<>(typeSupplier, bindr);
 	}
 
 	@Override
-	public <NewType> Function<BoundContainedType, IHolder<NewType>> lift(
-			final Function<BoundContainedType, NewType> func) {
-		if(func == null) throw new NullPointerException("Function to lift must not be null");
+	public <NewType> Function<BoundContainedType, IHolder<NewType>>
+			lift(final Function<BoundContainedType, NewType> func) {
+		if (func == null)
+			throw new NullPointerException("Function to lift must not be null");
 
-		return (val) -> {
+		return val -> {
 			return new Lazy<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<BoundContainedType, MappedType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <MappedType> IHolder<MappedType>
+			map(final Function<BoundContainedType, MappedType> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
 		/* Prepare a list of pending actions. */
-		final IList<UnaryOperator<BoundContainedType>> pendingActions = new FunctionalList<>();
+		final IList<UnaryOperator<BoundContainedType>> pendingActions
+				= new FunctionalList<>();
 		actions.forEach(pendingActions::add);
 
 		/* Prepare the new supplier. */
@@ -95,14 +102,12 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 			IHolder<BoundContainedType> oldHolder = boundHolder;
 
 			/* Bound the value if it hasn't been bound. */
-			if(!holderBound) {
+			if (!holderBound) {
 				oldHolder = oldSupplier.get().unwrap(binder);
 			}
 
 			/* Apply pending actions. */
-			return pendingActions.reduceAux(oldHolder.getValue(), (action, state) -> {
-				return action.apply(state);
-			}, (value) -> mapper.apply(value));
+			return pendingActions.reduceAux(oldHolder.getValue(), (action, state) -> action.apply(state), value -> mapper.apply(value));
 		};
 
 		return new Lazy<>(typeSupplier);
@@ -110,14 +115,17 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 
 	@Override
 	public String toString() {
-		if(holderBound) return boundHolder.toString();
+		if (holderBound)
+			return boundHolder.toString();
 
 		return "(unmaterialized)";
 	}
 
 	@Override
-	public IHolder<BoundContainedType> transform(final UnaryOperator<BoundContainedType> transformer) {
-		if(transformer == null) throw new NullPointerException("Transformer must not be null");
+	public IHolder<BoundContainedType>
+			transform(final UnaryOperator<BoundContainedType> transformer) {
+		if (transformer == null)
+			throw new NullPointerException("Transformer must not be null");
 
 		actions.add(transformer);
 
@@ -125,10 +133,12 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<BoundContainedType, UnwrappedType> unwrapper) {
-		if(unwrapper == null) throw new NullPointerException("Unwrapper must not be null");
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<BoundContainedType, UnwrappedType> unwrapper) {
+		if (unwrapper == null)
+			throw new NullPointerException("Unwrapper must not be null");
 
-		if(!holderBound) {
+		if (!holderBound) {
 			boundHolder = oldSupplier.get().unwrap(binder::apply);
 		}
 
diff --git a/src/main/java/bjc/data/internals/BoundLazyPair.java b/src/main/java/bjc/data/internals/BoundLazyPair.java
index 105b410..e081c04 100644
--- a/src/main/java/bjc/data/internals/BoundLazyPair.java
+++ b/src/main/java/bjc/data/internals/BoundLazyPair.java
@@ -15,7 +15,8 @@ import bjc.data.LazyPair;
  * @author Ben Culkin
  */
 @SuppressWarnings("javadoc")
-public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPair<NewLeft, NewRight> {
+public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight>
+		implements IPair<NewLeft, NewRight> {
 	/* The supplier of the left value. */
 	private final Supplier<OldLeft> leftSupplier;
 	/* The supplier of the right value. */
@@ -34,16 +35,17 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	 * Create a new bound lazy pair.
 	 *
 	 * @param leftSupp
-	 *        The supplier for the left value.
+	 *                  The supplier for the left value.
 	 *
 	 * @param rightSupp
-	 *        The supplier for the right value.
+	 *                  The supplier for the right value.
 	 *
 	 * @param bindr
-	 *        The function to use to bind the left and right into a new
-	 *        pair.
+	 *                  The function to use to bind the left and right into a new
+	 *                  pair.
 	 */
-	public BoundLazyPair(final Supplier<OldLeft> leftSupp, final Supplier<OldRight> rightSupp,
+	public BoundLazyPair(final Supplier<OldLeft> leftSupp,
+			final Supplier<OldRight> rightSupp,
 			final BiFunction<OldLeft, OldRight, IPair<NewLeft, NewRight>> bindr) {
 		leftSupplier = leftSupp;
 		rightSupplier = rightSupp;
@@ -53,54 +55,53 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	@Override
 	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
 			final BiFunction<NewLeft, NewRight, IPair<BoundLeft, BoundRight>> bindr) {
-		if(bindr == null) throw new NullPointerException("Binder must not be null");
+		if (bindr == null)
+			throw new NullPointerException("Binder must not be null");
 
 		final IHolder<IPair<NewLeft, NewRight>> newPair = new Identity<>(boundPair);
 		final IHolder<Boolean> newPairMade = new Identity<>(pairBound);
 
 		final Supplier<NewLeft> leftSupp = () -> {
-			if(!newPairMade.getValue()) {
+			if (!newPairMade.getValue()) {
 				/*
-				 * If the pair hasn't been bound before, bind
-				 * it.
+				 * If the pair hasn't been bound before, bind it.
 				 */
 				newPair.replace(binder.apply(leftSupplier.get(), rightSupplier.get()));
 
 				newPairMade.replace(true);
 			}
 
-			return newPair.unwrap((pair) -> pair.getLeft());
+			return newPair.unwrap(pair -> pair.getLeft());
 		};
 
 		final Supplier<NewRight> rightSupp = () -> {
-			if(!newPairMade.getValue()) {
+			if (!newPairMade.getValue()) {
 				/*
-				 * If the pair hasn't been bound before, bind
-				 * it.
+				 * If the pair hasn't been bound before, bind it.
 				 */
 				newPair.replace(binder.apply(leftSupplier.get(), rightSupplier.get()));
 
 				newPairMade.replace(true);
 			}
 
-			return newPair.unwrap((pair) -> pair.getRight());
+			return newPair.unwrap(pair -> pair.getRight());
 		};
 
 		return new BoundLazyPair<>(leftSupp, rightSupp, bindr);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, NewRight> bindLeft(
-			final Function<NewLeft, IPair<BoundLeft, NewRight>> leftBinder) {
-		if(leftBinder == null) throw new NullPointerException("Left binder must not be null");
+	public <BoundLeft> IPair<BoundLeft, NewRight>
+			bindLeft(final Function<NewLeft, IPair<BoundLeft, NewRight>> leftBinder) {
+		if (leftBinder == null)
+			throw new NullPointerException("Left binder must not be null");
 
 		final Supplier<NewLeft> leftSupp = () -> {
 			IPair<NewLeft, NewRight> newPair = boundPair;
 
-			if(!pairBound) {
+			if (!pairBound) {
 				/*
-				 * If the pair hasn't been bound before, bind
-				 * it.
+				 * If the pair hasn't been bound before, bind it.
 				 */
 				newPair = binder.apply(leftSupplier.get(), rightSupplier.get());
 			}
@@ -112,17 +113,17 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	}
 
 	@Override
-	public <BoundRight> IPair<NewLeft, BoundRight> bindRight(
-			final Function<NewRight, IPair<NewLeft, BoundRight>> rightBinder) {
-		if(rightBinder == null) throw new NullPointerException("Right binder must not be null");
+	public <BoundRight> IPair<NewLeft, BoundRight>
+			bindRight(final Function<NewRight, IPair<NewLeft, BoundRight>> rightBinder) {
+		if (rightBinder == null)
+			throw new NullPointerException("Right binder must not be null");
 
 		final Supplier<NewRight> rightSupp = () -> {
 			IPair<NewLeft, NewRight> newPair = boundPair;
 
-			if(!pairBound) {
+			if (!pairBound) {
 				/*
-				 * If the pair hasn't been bound before, bind
-				 * it.
+				 * If the pair hasn't been bound before, bind it.
 				 */
 				newPair = binder.apply(leftSupplier.get(), rightSupplier.get());
 			}
@@ -134,35 +135,37 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			final IPair<OtherLeft, OtherRight> otherPair,
-			final BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner,
-			final BiFunction<NewRight, OtherRight, CombinedRight> rightCombiner) {
-		if(otherPair == null) {
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(final IPair<OtherLeft, OtherRight> otherPair,
+					final BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner,
+					final BiFunction<NewRight, OtherRight, CombinedRight> rightCombiner) {
+		if (otherPair == null) {
 			throw new NullPointerException("Other pair must not be null");
-		} else if(leftCombiner == null) {
+		} else if (leftCombiner == null) {
 			throw new NullPointerException("Left combiner must not be null");
-		} else if(rightCombiner == null) {
+		} else if (rightCombiner == null) {
 			throw new NullPointerException("Right combiner must not be null");
 		}
 
-		return otherPair.bind((otherLeft, otherRight) -> {
-			return bind((leftVal, rightVal) -> {
-				CombinedLeft cLeft = leftCombiner.apply(leftVal, otherLeft);
-				CombinedRight cRight = rightCombiner.apply(rightVal, otherRight);
+		return otherPair.bind((otherLeft, otherRight) -> bind((leftVal, rightVal) -> {
+			CombinedLeft cLeft = leftCombiner.apply(leftVal, otherLeft);
+			CombinedRight cRight = rightCombiner.apply(rightVal, otherRight);
 
-				return new LazyPair<>(cLeft, cRight);
-			});
-		});
+			return new LazyPair<>(cLeft, cRight);
+		}));
 	}
 
 	@Override
-	public <NewLeftType> IPair<NewLeftType, NewRight> mapLeft(final Function<NewLeft, NewLeftType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewLeftType> IPair<NewLeftType, NewRight>
+			mapLeft(final Function<NewLeft, NewLeftType> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
 		final Supplier<NewLeftType> leftSupp = () -> {
-			if(!pairBound) {
-				final NewLeft leftVal = binder.apply(leftSupplier.get(), rightSupplier.get()).getLeft();
+			if (!pairBound) {
+				final NewLeft leftVal
+						= binder.apply(leftSupplier.get(), rightSupplier.get()).getLeft();
 
 				return mapper.apply(leftVal);
 			}
@@ -171,7 +174,8 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 		};
 
 		final Supplier<NewRight> rightSupp = () -> {
-			if(!pairBound) return binder.apply(leftSupplier.get(), rightSupplier.get()).getRight();
+			if (!pairBound)
+				return binder.apply(leftSupplier.get(), rightSupplier.get()).getRight();
 
 			return boundPair.getRight();
 		};
@@ -180,19 +184,22 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	}
 
 	@Override
-	public <NewRightType> IPair<NewLeft, NewRightType> mapRight(final Function<NewRight, NewRightType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <NewRightType> IPair<NewLeft, NewRightType>
+			mapRight(final Function<NewRight, NewRightType> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
 		final Supplier<NewLeft> leftSupp = () -> {
-			if(!pairBound) return binder.apply(leftSupplier.get(), rightSupplier.get()).getLeft();
+			if (!pairBound)
+				return binder.apply(leftSupplier.get(), rightSupplier.get()).getLeft();
 
 			return boundPair.getLeft();
 		};
 
 		final Supplier<NewRightType> rightSupp = () -> {
-			if(!pairBound) {
-				final NewRight rightVal = binder.apply(leftSupplier.get(), rightSupplier.get())
-						.getRight();
+			if (!pairBound) {
+				final NewRight rightVal = binder
+						.apply(leftSupplier.get(), rightSupplier.get()).getRight();
 
 				return mapper.apply(rightVal);
 			}
@@ -204,10 +211,12 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 	}
 
 	@Override
-	public <MergedType> MergedType merge(final BiFunction<NewLeft, NewRight, MergedType> merger) {
-		if(merger == null) throw new NullPointerException("Merger must not be null");
+	public <MergedType> MergedType
+			merge(final BiFunction<NewLeft, NewRight, MergedType> merger) {
+		if (merger == null)
+			throw new NullPointerException("Merger must not be null");
 
-		if(!pairBound) {
+		if (!pairBound) {
 			/*
 			 * If the pair isn't bound yet, bind it.
 			 */
@@ -221,7 +230,8 @@ public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPai
 
 	@Override
 	public String toString() {
-		if(pairBound) return boundPair.toString();
+		if (pairBound)
+			return boundPair.toString();
 
 		return "(un-materialized)";
 	}
diff --git a/src/main/java/bjc/data/internals/BoundListHolder.java b/src/main/java/bjc/data/internals/BoundListHolder.java
index 8f8cab4..1193c8d 100644
--- a/src/main/java/bjc/data/internals/BoundListHolder.java
+++ b/src/main/java/bjc/data/internals/BoundListHolder.java
@@ -21,48 +21,58 @@ public class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new list of holders.
 	 *
 	 * @param toHold
-	 *        The list of holders to, well, hold.
+	 *               The list of holders to, well, hold.
 	 */
 	public BoundListHolder(final IList<IHolder<ContainedType>> toHold) {
 		heldHolders = toHold;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
-		if(binder == null) throw new NullPointerException("Binder must not be null");
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+		if (binder == null)
+			throw new NullPointerException("Binder must not be null");
 
-		final IList<IHolder<BoundType>> boundHolders = heldHolders.map((containedHolder) -> {
-			return containedHolder.bind(binder);
-		});
+		final IList<IHolder<BoundType>> boundHolders
+				= heldHolders.map(containedHolder -> {
+					return containedHolder.bind(binder);
+				});
 
 		return new BoundListHolder<>(boundHolders);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		if(func == null) throw new NullPointerException("Function to lift must not be null");
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		if (func == null)
+			throw new NullPointerException("Function to lift must not be null");
 
-		return (val) -> {
+		return val -> {
 			return new ListHolder<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
-		final IList<IHolder<MappedType>> mappedHolders = heldHolders.map((containedHolder) -> {
-			return containedHolder.map(mapper);
-		});
+		final IList<IHolder<MappedType>> mappedHolders
+				= heldHolders.map(containedHolder -> {
+					return containedHolder.map(mapper);
+				});
 
 		return new BoundListHolder<>(mappedHolders);
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
-		if(transformer == null) throw new NullPointerException("Transformer must not be null");
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
+		if (transformer == null)
+			throw new NullPointerException("Transformer must not be null");
 
-		heldHolders.forEach((containedHolder) -> {
+		heldHolders.forEach(containedHolder -> {
 			containedHolder.transform(transformer);
 		});
 
@@ -70,8 +80,10 @@ public class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		if(unwrapper == null) throw new NullPointerException("Unwrapper must not be null");
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		if (unwrapper == null)
+			throw new NullPointerException("Unwrapper must not be null");
 
 		/*
 		 * @NOTE Is there another way we could want to do this?
diff --git a/src/main/java/bjc/data/internals/HalfBoundLazyPair.java b/src/main/java/bjc/data/internals/HalfBoundLazyPair.java
index 4f28012..6bcb6ae 100644
--- a/src/main/java/bjc/data/internals/HalfBoundLazyPair.java
+++ b/src/main/java/bjc/data/internals/HalfBoundLazyPair.java
@@ -23,7 +23,8 @@ import bjc.data.LazyPair;
  * @author Ben Culkin
  */
 @SuppressWarnings("javadoc")
-public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewLeft, NewRight> {
+public class HalfBoundLazyPair<OldType, NewLeft, NewRight>
+		implements IPair<NewLeft, NewRight> {
 	/* The supplier of the old value. */
 	private final Supplier<OldType> oldSupplier;
 
@@ -39,10 +40,10 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 	 * Create a new half-bound lazy pair.
 	 *
 	 * @param oldSupp
-	 *        The supplier of the old value.
+	 *                The supplier of the old value.
 	 *
 	 * @param bindr
-	 *        The function to use to create the pair from the old value.
+	 *                The function to use to create the pair from the old value.
 	 */
 	public HalfBoundLazyPair(final Supplier<OldType> oldSupp,
 			final Function<OldType, IPair<NewLeft, NewRight>> bindr) {
@@ -57,35 +58,35 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 		final IHolder<Boolean> newPairMade = new Identity<>(pairBound);
 
 		final Supplier<NewLeft> leftSupp = () -> {
-			if(!newPairMade.getValue()) {
+			if (!newPairMade.getValue()) {
 				/* Bind the pair if it hasn't been bound yet. */
 				newPair.replace(binder.apply(oldSupplier.get()));
 				newPairMade.replace(true);
 			}
 
-			return newPair.unwrap((pair) -> pair.getLeft());
+			return newPair.unwrap(pair -> pair.getLeft());
 		};
 
 		final Supplier<NewRight> rightSupp = () -> {
-			if(!newPairMade.getValue()) {
+			if (!newPairMade.getValue()) {
 				/* Bind the pair if it hasn't been bound yet. */
 				newPair.replace(binder.apply(oldSupplier.get()));
 				newPairMade.replace(true);
 			}
 
-			return newPair.unwrap((pair) -> pair.getRight());
+			return newPair.unwrap(pair -> pair.getRight());
 		};
 
 		return new BoundLazyPair<>(leftSupp, rightSupp, bindr);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, NewRight> bindLeft(
-			final Function<NewLeft, IPair<BoundLeft, NewRight>> leftBinder) {
+	public <BoundLeft> IPair<BoundLeft, NewRight>
+			bindLeft(final Function<NewLeft, IPair<BoundLeft, NewRight>> leftBinder) {
 		final Supplier<NewLeft> leftSupp = () -> {
 			IPair<NewLeft, NewRight> newPair = boundPair;
 
-			if(!pairBound) {
+			if (!pairBound) {
 				newPair = binder.apply(oldSupplier.get());
 			}
 
@@ -96,12 +97,12 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 	}
 
 	@Override
-	public <BoundRight> IPair<NewLeft, BoundRight> bindRight(
-			final Function<NewRight, IPair<NewLeft, BoundRight>> rightBinder) {
+	public <BoundRight> IPair<NewLeft, BoundRight>
+			bindRight(final Function<NewRight, IPair<NewLeft, BoundRight>> rightBinder) {
 		final Supplier<NewRight> rightSupp = () -> {
 			IPair<NewLeft, NewRight> newPair = boundPair;
 
-			if(!pairBound) {
+			if (!pairBound) {
 				newPair = binder.apply(oldSupplier.get());
 			}
 
@@ -112,24 +113,25 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-			final IPair<OtherLeft, OtherRight> otherPair,
-			final BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner,
-			final BiFunction<NewRight, OtherRight, CombinedRight> rightCombiner) {
-		return otherPair.bind((otherLeft, otherRight) -> {
-			return bind((leftVal, rightVal) -> {
-				CombinedLeft cLeft = leftCombiner.apply(leftVal, otherLeft);
-				CombinedRight cRight = rightCombiner.apply(rightVal, otherRight);
-
-				return new LazyPair<>(cLeft, cRight);
-			});
-		});
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
+			IPair<CombinedLeft, CombinedRight>
+			combine(final IPair<OtherLeft, OtherRight> otherPair,
+					final BiFunction<NewLeft, OtherLeft, CombinedLeft> leftCombiner,
+					final BiFunction<NewRight, OtherRight, CombinedRight> rightCombiner) {
+		return otherPair.bind((otherLeft, otherRight) -> bind((leftVal, rightVal) -> {
+			CombinedLeft cLeft = leftCombiner.apply(leftVal, otherLeft);
+			CombinedRight cRight = rightCombiner.apply(rightVal, otherRight);
+
+			return new LazyPair<>(cLeft, cRight);
+		}));
 	}
 
 	@Override
-	public <NewLeftType> IPair<NewLeftType, NewRight> mapLeft(final Function<NewLeft, NewLeftType> mapper) {
+	public <NewLeftType> IPair<NewLeftType, NewRight>
+			mapLeft(final Function<NewLeft, NewLeftType> mapper) {
 		final Supplier<NewLeftType> leftSupp = () -> {
-			if(pairBound) return mapper.apply(boundPair.getLeft());
+			if (pairBound)
+				return mapper.apply(boundPair.getLeft());
 
 			final NewLeft leftVal = binder.apply(oldSupplier.get()).getLeft();
 
@@ -137,7 +139,8 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 		};
 
 		final Supplier<NewRight> rightSupp = () -> {
-			if(pairBound) return boundPair.getRight();
+			if (pairBound)
+				return boundPair.getRight();
 
 			return binder.apply(oldSupplier.get()).getRight();
 		};
@@ -146,15 +149,18 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 	}
 
 	@Override
-	public <NewRightType> IPair<NewLeft, NewRightType> mapRight(final Function<NewRight, NewRightType> mapper) {
+	public <NewRightType> IPair<NewLeft, NewRightType>
+			mapRight(final Function<NewRight, NewRightType> mapper) {
 		final Supplier<NewLeft> leftSupp = () -> {
-			if(pairBound) return boundPair.getLeft();
+			if (pairBound)
+				return boundPair.getLeft();
 
 			return binder.apply(oldSupplier.get()).getLeft();
 		};
 
 		final Supplier<NewRightType> rightSupp = () -> {
-			if(pairBound) return mapper.apply(boundPair.getRight());
+			if (pairBound)
+				return mapper.apply(boundPair.getRight());
 
 			final NewRight rightVal = binder.apply(oldSupplier.get()).getRight();
 
@@ -165,8 +171,9 @@ public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewL
 	}
 
 	@Override
-	public <MergedType> MergedType merge(final BiFunction<NewLeft, NewRight, MergedType> merger) {
-		if(!pairBound) {
+	public <MergedType> MergedType
+			merge(final BiFunction<NewLeft, NewRight, MergedType> merger) {
+		if (!pairBound) {
 			boundPair = binder.apply(oldSupplier.get());
 
 			pairBound = true;
diff --git a/src/main/java/bjc/data/internals/WrappedLazy.java b/src/main/java/bjc/data/internals/WrappedLazy.java
index 17d2309..cda86fd 100644
--- a/src/main/java/bjc/data/internals/WrappedLazy.java
+++ b/src/main/java/bjc/data/internals/WrappedLazy.java
@@ -11,7 +11,7 @@ import bjc.data.Lazy;
  *
  * @author Ben Culkin
  * @param <ContainedType>
- *        The type of the wrapped value.
+ *                        The type of the wrapped value.
  */
 public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	/* Held value. */
@@ -21,19 +21,18 @@ public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new wrapped lazy value.
 	 *
 	 * @param wrappedHolder
-	 *        The holder to make lazy.
+	 *                      The holder to make lazy.
 	 */
 	public WrappedLazy(final IHolder<ContainedType> wrappedHolder) {
 		held = new Lazy<>(wrappedHolder);
 	}
 
 	/*
-	 * This has an extra parameter, because otherwise it erases to the same
-	 * as the public one.
+	 * This has an extra parameter, because otherwise it erases to the same as the
+	 * public one.
 	 *
-	 * This is a case where reified generics would be useful, because then
-	 * the compiler could know which one we meant without the dummy
-	 * parameter.
+	 * This is a case where reified generics would be useful, because then the
+	 * compiler could know which one we meant without the dummy parameter.
 	 */
 	private WrappedLazy(final IHolder<IHolder<ContainedType>> wrappedHolder,
 			@SuppressWarnings("unused") final boolean dummy) {
@@ -41,8 +40,9 @@ public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
-		final IHolder<IHolder<BoundType>> newHolder = held.map((containedHolder) -> {
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+		final IHolder<IHolder<BoundType>> newHolder = held.map(containedHolder -> {
 			return containedHolder.bind(binder);
 		});
 
@@ -50,15 +50,17 @@ public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return (val) -> {
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> {
 			return new Lazy<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
-		final IHolder<IHolder<MappedType>> newHolder = held.map((containedHolder) -> {
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
+		final IHolder<IHolder<MappedType>> newHolder = held.map(containedHolder -> {
 			return containedHolder.map(mapper);
 		});
 
@@ -66,8 +68,9 @@ public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
-		held.transform((containedHolder) -> {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
+		held.transform(containedHolder -> {
 			return containedHolder.transform(transformer);
 		});
 
@@ -75,8 +78,9 @@ public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		return held.unwrap((containedHolder) -> {
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		return held.unwrap(containedHolder -> {
 			return containedHolder.unwrap(unwrapper);
 		});
 	}
diff --git a/src/main/java/bjc/data/internals/WrappedOption.java b/src/main/java/bjc/data/internals/WrappedOption.java
index eb4d120..6becc16 100644
--- a/src/main/java/bjc/data/internals/WrappedOption.java
+++ b/src/main/java/bjc/data/internals/WrappedOption.java
@@ -11,7 +11,7 @@ import bjc.data.Option;
  *
  * @author Ben Culkin.
  * @param <ContainedType>
- *        The wrapped type.
+ *                        The wrapped type.
  */
 public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	/* The held value. */
@@ -21,16 +21,15 @@ public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new wrapped option.
 	 *
 	 * @param seedValue
-	 *        The value to wrap.
+	 *                  The value to wrap.
 	 */
 	public WrappedOption(final IHolder<ContainedType> seedValue) {
 		held = new Option<>(seedValue);
 	}
 
 	/*
-	 * The dummy parameter is to ensure the compiler can pick the right
-	 * method, because without this method erases to the same type as the
-	 * public one.
+	 * The dummy parameter is to ensure the compiler can pick the right method,
+	 * because without this method erases to the same type as the public one.
 	 */
 	private WrappedOption(final IHolder<IHolder<ContainedType>> toHold,
 			@SuppressWarnings("unused") final boolean dummy) {
@@ -38,10 +37,12 @@ public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
-		final IHolder<IHolder<BoundType>> newHolder = held.map((containedHolder) -> {
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+		final IHolder<IHolder<BoundType>> newHolder = held.map(containedHolder -> {
 			return containedHolder.bind((containedValue) -> {
-				if(containedValue == null) return new Option<>(null);
+				if (containedValue == null)
+					return new Option<>(null);
 
 				return binder.apply(containedValue);
 			});
@@ -51,17 +52,20 @@ public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		return (val) -> {
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		return val -> {
 			return new Option<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
-		final IHolder<IHolder<MappedType>> newHolder = held.map((containedHolder) -> {
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
+		final IHolder<IHolder<MappedType>> newHolder = held.map(containedHolder -> {
 			return containedHolder.map((containedValue) -> {
-				if(containedValue == null) return null;
+				if (containedValue == null)
+					return null;
 
 				return mapper.apply(containedValue);
 			});
@@ -71,10 +75,12 @@ public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
-		held.transform((containedHolder) -> {
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
+		held.transform(containedHolder -> {
 			return containedHolder.transform((containedValue) -> {
-				if(containedValue == null) return null;
+				if (containedValue == null)
+					return null;
 
 				return transformer.apply(containedValue);
 			});
@@ -84,10 +90,12 @@ public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		return held.unwrap((containedHolder) -> {
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		return held.unwrap(containedHolder -> {
 			return containedHolder.unwrap((containedValue) -> {
-				if(containedValue == null) return null;
+				if (containedValue == null)
+					return null;
 
 				return unwrapper.apply(containedValue);
 			});