From 27bf571d6413c3cc6a5d664b5bddd38d21d7b1cd Mon Sep 17 00:00:00 2001
From: EVE <EVE@EVE-PC>
Date: Mon, 13 Mar 2017 16:42:21 -0400
Subject: Formatting

---
 .../java/bjc/utils/funcdata/theory/Bifunctor.java  | 84 +++++++++-------------
 .../java/bjc/utils/funcdata/theory/Functor.java    | 17 +++--
 2 files changed, 41 insertions(+), 60 deletions(-)

(limited to 'BJC-Utils2/src/main/java/bjc/utils/funcdata/theory')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
index a8f27c6..fa69f31 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Bifunctor.java
@@ -7,9 +7,9 @@ import java.util.function.Function;
  * 
  * @author ben
  * @param <LeftType>
- *            The type stored on the 'left' of the pair
+ *                The type stored on the 'left' of the pair
  * @param <RightType>
- *            The type stored on the 'right' of the pair
+ *                The type stored on the 'right' of the pair
  *
  */
 public interface Bifunctor<LeftType, RightType> {
@@ -18,44 +18,31 @@ public interface Bifunctor<LeftType, RightType> {
 	 * parts of a pair
 	 * 
 	 * @param <OldLeft>
-	 *            The old left type of the pair
+	 *                The old left type of the pair
 	 * @param <OldRight>
-	 *            The old right type of the pair
+	 *                The old right type of the pair
 	 * @param <NewLeft>
-	 *            The new left type of the pair
+	 *                The new left type of the pair
 	 * @param <NewRight>
-	 *            The new right type of the pair
+	 *                The new right type of the pair
 	 * @param leftFunc
-	 *            The function that maps over the left of the pair
+	 *                The function that maps over the left of the pair
 	 * @param rightFunc
-	 *            The function that maps over the right of the pair
+	 *                The function that maps over the right of the pair
 	 * @return A function that maps over both parts of the pair
 	 */
-	public default <OldLeft, OldRight, NewLeft,
-			NewRight> Function<Bifunctor<OldLeft, OldRight>,
-					Bifunctor<NewLeft, NewRight>> bimap(
-							Function<OldLeft, NewLeft> leftFunc,
-							Function<OldRight, NewRight> rightFunc) {
-		Function<Bifunctor<OldLeft, OldRight>,
-				Bifunctor<NewLeft, NewRight>> bimappedFunc = (argPair) -> {
-					Function<Bifunctor<OldLeft, OldRight>,
-							Bifunctor<NewLeft,
-									OldRight>> leftMapper = argPair.<
-											OldLeft, OldRight,
-											NewLeft> fmapLeft(leftFunc);
+	public default <OldLeft, OldRight, NewLeft, NewRight> Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, NewRight>> bimap(
+			Function<OldLeft, NewLeft> leftFunc, Function<OldRight, NewRight> rightFunc) {
+		Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, NewRight>> bimappedFunc = (argPair) -> {
+			Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, OldRight>> leftMapper = argPair
+					.<OldLeft, OldRight, NewLeft>fmapLeft(leftFunc);
 
-					Bifunctor<NewLeft,
-							OldRight> leftMappedFunctor = leftMapper
-									.apply(argPair);
-					Function<Bifunctor<NewLeft, OldRight>,
-							Bifunctor<NewLeft,
-									NewRight>> rightMapper = leftMappedFunctor
-											.<NewLeft, OldRight,
-													NewRight> fmapRight(
-															rightFunc);
+			Bifunctor<NewLeft, OldRight> leftMappedFunctor = leftMapper.apply(argPair);
+			Function<Bifunctor<NewLeft, OldRight>, Bifunctor<NewLeft, NewRight>> rightMapper = leftMappedFunctor
+					.<NewLeft, OldRight, NewRight>fmapRight(rightFunc);
 
-					return rightMapper.apply(leftMappedFunctor);
-				};
+			return rightMapper.apply(leftMappedFunctor);
+		};
 
 		return bimappedFunc;
 	}
@@ -64,40 +51,35 @@ public interface Bifunctor<LeftType, RightType> {
 	 * Lift a function to operate over the left part of this pair
 	 * 
 	 * @param <OldLeft>
-	 *            The old left type of the pair
+	 *                The old left type of the pair
 	 * @param <OldRight>
-	 *            The old right type of the pair
+	 *                The old right type of the pair
 	 * @param <NewLeft>
-	 *            The new left type of the pair
+	 *                The new left type of the pair
 	 * @param func
-	 *            The function to lift to work over the left side of the
-	 *            pair
+	 *                The function to lift to work over the left side of the
+	 *                pair
 	 * @return The function lifted to work over the left side of bifunctors
 	 */
-	public <OldLeft, OldRight,
-			NewLeft> Function<Bifunctor<OldLeft, OldRight>,
-					Bifunctor<NewLeft, OldRight>> fmapLeft(
-							Function<OldLeft, NewLeft> func);
+	public <OldLeft, OldRight, NewLeft> Function<Bifunctor<OldLeft, OldRight>, Bifunctor<NewLeft, OldRight>> fmapLeft(
+			Function<OldLeft, NewLeft> func);
 
 	/**
 	 * Lift a function to operate over the right part of this pair
 	 * 
 	 * @param <OldLeft>
-	 *            The old left type of the pair
+	 *                The old left type of the pair
 	 * @param <OldRight>
-	 *            The old right type of the pair
+	 *                The old right type of the pair
 	 * @param <NewRight>
-	 *            The new right type of the pair
+	 *                The new right type of the pair
 	 * @param func
-	 *            The function to lift to work over the right side of the
-	 *            pair
-	 * @return The function lifted to work over the right side of
-	 *         bifunctors
+	 *                The function to lift to work over the right side of
+	 *                the pair
+	 * @return The function lifted to work over the right side of bifunctors
 	 */
-	public <OldLeft, OldRight,
-			NewRight> Function<Bifunctor<OldLeft, OldRight>,
-					Bifunctor<OldLeft, NewRight>> fmapRight(
-							Function<OldRight, NewRight> func);
+	public <OldLeft, OldRight, NewRight> Function<Bifunctor<OldLeft, OldRight>, Bifunctor<OldLeft, NewRight>> fmapRight(
+			Function<OldRight, NewRight> func);
 
 	/**
 	 * Get the value contained on the left of this bifunctor
diff --git a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java
index 9749d95..a5007f1 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/funcdata/theory/Functor.java
@@ -8,28 +8,27 @@ import java.util.function.Function;
  * 
  * @author ben
  * @param <ContainedType>
- *            The value inside the functor
+ *                The value inside the functor
  */
 public interface Functor<ContainedType> {
 	/**
 	 * Converts a normal function to operate over values in a functor.
 	 * 
 	 * N.B: Even though the type signature implies that you can apply the
-	 * resulting function to any type of functor, it is only safe to call
-	 * it on instances of the type of functor you called fmap on.
+	 * resulting function to any type of functor, it is only safe to call it
+	 * on instances of the type of functor you called fmap on.
 	 * 
 	 * @param <ArgType>
-	 *            The argument of the function
+	 *                The argument of the function
 	 * @param <ReturnType>
-	 *            The return type of the function
+	 *                The return type of the function
 	 * @param func
-	 *            The function to convert
+	 *                The function to convert
 	 * @return The passed in function converted to work over a particular
 	 *         type of functors
 	 */
-	public <ArgType, ReturnType> 
-		Function<Functor<ArgType>, Functor<ReturnType>> 
-		fmap(Function<ArgType, ReturnType> func);
+	public <ArgType, ReturnType> Function<Functor<ArgType>, Functor<ReturnType>> fmap(
+			Function<ArgType, ReturnType> func);
 
 	/**
 	 * Retrieve the thing inside this functor
-- 
cgit v1.2.3