1 files changed, 41 insertions, 47 deletions

diff --git a/src/main/java/bjc/data/LazyPair.java b/src/main/java/bjc/data/LazyPair.java
index e668cd4..048254a 100644
--- a/src/main/java/bjc/data/LazyPair.java
+++ b/src/main/java/bjc/data/LazyPair.java
@@ -18,7 +18,7 @@ import bjc.data.internals.HalfBoundLazyPair;
  * @param <RightType>
  *                    The type on the right side of the pair.
  */
-public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType> {
+public class LazyPair<LeftType, RightType> implements Pair<LeftType, RightType> {
 	/* The supplier for the left value. */
 	private Supplier<LeftType> leftSupplier;
 	/* The left value. */
@@ -70,17 +70,16 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundLeft, BoundRight> IPair<BoundLeft, BoundRight> bind(
-			final BiFunction<LeftType, RightType, IPair<BoundLeft, BoundRight>> binder) {
+	public <BoundLeft, BoundRight> Pair<BoundLeft, BoundRight> bind(
+			final BiFunction<LeftType, RightType, Pair<BoundLeft, BoundRight>> binder) {
 		return new BoundLazyPair<>(leftSupplier, rightSupplier, binder);
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType>
-			bindLeft(final Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+	public <BoundLeft> Pair<BoundLeft, RightType>
+			bindLeft(final Function<LeftType, Pair<BoundLeft, RightType>> leftBinder) {
 		final Supplier<LeftType> leftSupp = () -> {
-			if (leftMaterialized)
-				return leftValue;
+			if (leftMaterialized) return leftValue;
 
 			return leftSupplier.get();
 		};
@@ -89,11 +88,10 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundRight> IPair<LeftType, BoundRight> bindRight(
-			final Function<RightType, IPair<LeftType, BoundRight>> rightBinder) {
+	public <BoundRight> Pair<LeftType, BoundRight> bindRight(
+			final Function<RightType, Pair<LeftType, BoundRight>> rightBinder) {
 		final Supplier<RightType> rightSupp = () -> {
-			if (rightMaterialized)
-				return rightValue;
+			if (rightMaterialized) return rightValue;
 
 			return rightSupplier.get();
 		};
@@ -103,17 +101,19 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 
 	@Override
 	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight>
-			IPair<CombinedLeft, CombinedRight>
-			combine(final IPair<OtherLeft, OtherRight> otherPair,
+			Pair<CombinedLeft, CombinedRight>
+			combine(final Pair<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);
-		}));
+		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);
+			});
+		});
 	}
 
 	@Override
@@ -139,18 +139,16 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType>
+	public <NewLeft> Pair<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();
 		};
@@ -159,18 +157,16 @@ public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight>
+	public <NewRight> Pair<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());
 		};
@@ -231,37 +227,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))
+				if (other.leftValue != null) return false;
+			} else if (!leftValue.equals(other.leftValue)) {
 				return false;
-		} else
+			}
+		} else {
 			return false;
+		}
 
-		if (rightMaterialized != other.rightMaterialized)
-			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))
+				if (other.rightValue != null) return false;
+			} else if (!rightValue.equals(other.rightValue)) {
 				return false;
-		} else
+			}
+		} else {
 			return false;
+		}
 
 		return true;
 	}