result type
+ * @return the result of applying the appropriate morphism from whichever type is represented by this coproduct to R
+ */
+ R match(Function aFn, Function bFn);
+
+ /**
+ * Diverge this coproduct by introducing another possible type that it could represent.
+ *
+ * It's important to understand that this does not alter the essential value represented by this coproduct: if the
+ * value was an A before divergence, it is still an A; likewise with B.
+ *
+ * The purpose of this operation is to allow the use of a more convergent coproduct with a more divergent one; that
+ * is, if a CoProduct3<String, Integer, Boolean> is expected, a CoProduct2<String,
+ * Integer> should suffice.
+ *
+ * Generally, we use inheritance to make this a non-issue; however, with coproducts of differing magnitudes, we
+ * cannot guarantee variance compatibility in one direction conveniently at construction time, and in the other
+ * direction, at all. A {@link CoProduct2} could not be a {@link CoProduct3} without specifying all type parameters
+ * that are possible for a {@link CoProduct3} - more specifically, the third possible type - which is not
+ * necessarily known at construction time, or even useful if never used in the context of a {@link CoProduct3}. The
+ * inverse inheritance relationship - {@link CoProduct3} < {@link CoProduct2} - is inherently unsound, as a
+ * {@link CoProduct3} cannot correctly implement {@link CoProduct2#match}, given that the third type C
+ * is always possible.
+ *
+ * For this reason, there is a diverge method supported between all CoProduct types of
+ * single magnitude difference.
+ *
+ * @param the additional possible type of this coproduct
+ * @return a Coproduct3<A, B, C>
+ */
+ default CoProduct3 diverge() {
+ return match(CoProduct3::a, CoProduct3::b);
+ }
+
+ @Override
+ default CoProduct2 fmap(Function fn) {
+ return biMapR(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct2 biMapL(Function fn) {
+ return (CoProduct2) Bifunctor.super.biMapL(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct2 biMapR(Function fn) {
+ return (CoProduct2) Bifunctor.super.biMapR(fn);
+ }
+
+ @Override
+ default CoProduct2 biMap(Function lFn,
+ Function rFn) {
+ return match(a -> a(lFn.apply(a)), b -> b(rFn.apply(b)));
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct2}.
+ *
+ * @param a the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @return the wrapped value as a CoProduct2<A, B>
+ */
+ static CoProduct2 a(A a) {
+ class _A implements CoProduct2 {
+
+ private final A a;
+
+ private _A(A a) {
+ this.a = a;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn) {
+ return aFn.apply(a);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _A
+ && Objects.equals(a, ((_A) other).a);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(a);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct2{" +
+ "a=" + a +
+ '}';
+ }
+ }
+
+ return new _A(a);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type B in a {@link CoProduct2}.
+ *
+ * @param b the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @return the wrapped value as a CoProduct2<A, B>
+ */
+ static CoProduct2 b(B b) {
+ class _B implements CoProduct2 {
+
+ private final B b;
+
+ private _B(B b) {
+ this.b = b;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn) {
+ return bFn.apply(b);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _B
+ && Objects.equals(b, ((_B) other).b);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(b);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct2{" +
+ "b=" + b +
+ '}';
+ }
+ }
+ return new _B(b);
+ }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct3.java b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct3.java
new file mode 100644
index 000000000..2dc66cede
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct3.java
@@ -0,0 +1,205 @@
+package com.jnape.palatable.lambda.adt.coproduct;
+
+import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.functor.Functor;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * A generalization of the coproduct of three types A, B, and C.
+ *
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @see CoProduct2
+ */
+@FunctionalInterface
+public interface CoProduct3 extends Functor, Bifunctor {
+
+ /**
+ * Type-safe convergence requiring a match against all potential types.
+ *
+ * @param aFn morphism A -> R
+ * @param bFn morphism B -> R
+ * @param cFn morphism C -> R
+ * @param result type
+ * @return the result of applying the appropriate morphism from whichever type is represented by this coproduct to R
+ * @see CoProduct2#match(Function, Function)
+ */
+ R match(Function aFn, Function bFn,
+ Function cFn);
+
+
+ /**
+ * Diverge this coproduct by introducing another possible type that it could represent.
+ *
+ * @param the additional possible type of this coproduct
+ * @return a Coproduct4<A, B, C, D>
+ * @see CoProduct2#diverge()
+ */
+ default CoProduct4 diverge() {
+ return match(CoProduct4::a, CoProduct4::b, CoProduct4::c);
+ }
+
+ @Override
+ default CoProduct3 fmap(Function fn) {
+ return biMapR(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct3 biMapL(Function fn) {
+ return (CoProduct3) Bifunctor.super.biMapL(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct3 biMapR(Function fn) {
+ return (CoProduct3) Bifunctor.super.biMapR(fn);
+ }
+
+ @Override
+ default CoProduct3 biMap(Function lFn,
+ Function rFn) {
+ return match(CoProduct3::a, b -> b(lFn.apply(b)), c -> c(rFn.apply(c)));
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct3}.
+ *
+ * @param a the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @return the wrapped value as a CoProduct3<A, B, C>
+ */
+ static CoProduct3 a(A a) {
+ class _A implements CoProduct3 {
+
+ private final A a;
+
+ private _A(A a) {
+ this.a = a;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn) {
+ return aFn.apply(a);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _A
+ && Objects.equals(a, ((_A) other).a);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(a);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct3{" +
+ "a=" + a +
+ '}';
+ }
+ }
+
+ return new _A(a);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct3}.
+ *
+ * @param b the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @return the wrapped value as a CoProduct3<A, B, C>
+ */
+ static CoProduct3 b(B b) {
+ class _B implements CoProduct3 {
+
+ private final B b;
+
+ private _B(B b) {
+ this.b = b;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn) {
+ return bFn.apply(b);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _B
+ && Objects.equals(b, ((_B) other).b);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(b);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct3{" +
+ "b=" + b +
+ '}';
+ }
+ }
+
+ return new _B(b);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct3}.
+ *
+ * @param c the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @return the wrapped value as a CoProduct3<A, B, C>
+ */
+ static CoProduct3 c(C c) {
+ class _C implements CoProduct3 {
+
+ private final C c;
+
+ private _C(C c) {
+ this.c = c;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn) {
+ return cFn.apply(c);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _C
+ && Objects.equals(c, ((_C) other).c);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(c);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct3{" +
+ "c=" + c +
+ '}';
+ }
+ }
+
+ return new _C(c);
+ }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct4.java b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct4.java
new file mode 100644
index 000000000..59f8f0043
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct4.java
@@ -0,0 +1,256 @@
+package com.jnape.palatable.lambda.adt.coproduct;
+
+import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.functor.Functor;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * A generalization of the coproduct of four types A, B, C, and D.
+ *
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @see CoProduct2
+ */
+@FunctionalInterface
+public interface CoProduct4 extends Functor, Bifunctor {
+
+ /**
+ * Type-safe convergence requiring a match against all potential types.
+ *
+ * @param aFn morphism A -> R
+ * @param bFn morphism B -> R
+ * @param cFn morphism C -> R
+ * @param dFn morphism D -> R
+ * @param result type
+ * @return the result of applying the appropriate morphism from whichever type is represented by this coproduct to R
+ * @see CoProduct2#match(Function, Function)
+ */
+ R match(Function aFn,
+ Function bFn,
+ Function cFn,
+ Function dFn);
+
+ /**
+ * Diverge this coproduct by introducing another possible type that it could represent.
+ *
+ * @param the additional possible type of this coproduct
+ * @return a Coproduct5<A, B, C, D, E>
+ * @see CoProduct2#diverge()
+ */
+ default CoProduct5 diverge() {
+ return match(CoProduct5::a, CoProduct5::b, CoProduct5::c, CoProduct5::d);
+ }
+
+ @Override
+ default CoProduct4 fmap(Function fn) {
+ return biMapR(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct4 biMapL(Function fn) {
+ return (CoProduct4) Bifunctor.super.biMapL(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct4 biMapR(Function fn) {
+ return (CoProduct4) Bifunctor.super.biMapR(fn);
+ }
+
+ @Override
+ default CoProduct4 biMap(Function lFn,
+ Function rFn) {
+ return match(CoProduct4::a, CoProduct4::b, c -> c(lFn.apply(c)), d -> d(rFn.apply(d)));
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct4}.
+ *
+ * @param a the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @return the wrapped value as a CoProduct4<A, B, C, D>
+ */
+ static CoProduct4 a(A a) {
+ class _A implements CoProduct4 {
+
+ private final A a;
+
+ private _A(A a) {
+ this.a = a;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn) {
+ return aFn.apply(a);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _A
+ && Objects.equals(a, ((_A) other).a);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(a);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct4{" +
+ "a=" + a +
+ '}';
+ }
+ }
+
+ return new _A(a);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type B in a {@link CoProduct4}.
+ *
+ * @param b the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @return the wrapped value as a CoProduct4<A, B, C, D>
+ */
+ static CoProduct4 b(B b) {
+ class _B implements CoProduct4 {
+
+ private final B b;
+
+ private _B(B b) {
+ this.b = b;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn) {
+ return bFn.apply(b);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _B
+ && Objects.equals(b, ((_B) other).b);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(b);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct4{" +
+ "b=" + b +
+ '}';
+ }
+ }
+ return new _B(b);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type C in a {@link CoProduct4}.
+ *
+ * @param c the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @return the wrapped value as a CoProduct4<A, B, C, D>
+ */
+ static CoProduct4 c(C c) {
+ class _C implements CoProduct4 {
+
+ private final C c;
+
+ private _C(C c) {
+ this.c = c;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn) {
+ return cFn.apply(c);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _C
+ && Objects.equals(c, ((_C) other).c);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(c);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct4{" +
+ "c=" + c +
+ '}';
+ }
+ }
+ return new _C(c);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type D in a {@link CoProduct4}.
+ *
+ * @param d the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @return the wrapped value as a CoProduct4<A, B, C, D>
+ */
+ static CoProduct4 d(D d) {
+ class _D implements CoProduct4 {
+
+ private final D d;
+
+ private _D(D d) {
+ this.d = d;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn) {
+ return dFn.apply(d);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _D
+ && Objects.equals(d, ((_D) other).d);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(d);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct4{" +
+ "d=" + d +
+ '}';
+ }
+ }
+
+ return new _D(d);
+ }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct5.java b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct5.java
new file mode 100644
index 000000000..2594f16df
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/adt/coproduct/CoProduct5.java
@@ -0,0 +1,308 @@
+package com.jnape.palatable.lambda.adt.coproduct;
+
+import com.jnape.palatable.lambda.functor.Bifunctor;
+import com.jnape.palatable.lambda.functor.Functor;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+/**
+ * A generalization of the coproduct of five types A, B, C, D, and
+ * E.
+ *
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @see CoProduct2
+ */
+@FunctionalInterface
+public interface CoProduct5 extends Functor, Bifunctor {
+
+ /**
+ * Type-safe convergence requiring a match against all potential types.
+ *
+ * @param aFn morphism A -> R
+ * @param bFn morphism B -> R
+ * @param cFn morphism C -> R
+ * @param dFn morphism D -> R
+ * @param eFn morphism E -> R
+ * @param result type
+ * @return the result of applying the appropriate morphism from whichever type is represented by this coproduct to R
+ * @see CoProduct2#match(Function, Function)
+ */
+ R match(Function aFn,
+ Function bFn,
+ Function cFn,
+ Function dFn,
+ Function eFn);
+
+ @Override
+ default CoProduct5 fmap(Function fn) {
+ return biMapR(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct5 biMapL(Function fn) {
+ return (CoProduct5) Bifunctor.super.biMapL(fn);
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ default CoProduct5 biMapR(Function fn) {
+ return (CoProduct5) Bifunctor.super.biMapR(fn);
+ }
+
+ @Override
+ default CoProduct5 biMap(Function lFn,
+ Function rFn) {
+ return match(CoProduct5::a, CoProduct5::b, CoProduct5::c, d -> d(lFn.apply(d)), e -> e(rFn.apply(e)));
+ }
+
+ /**
+ * Static factory method for wrapping a value of type A in a {@link CoProduct5}.
+ *
+ * @param a the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @return the wrapped value as a CoProduct5<A, B, C, D, E>
+ */
+ static CoProduct5 a(A a) {
+ class _A implements CoProduct5 {
+
+ private final A a;
+
+ private _A(A a) {
+ this.a = a;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn,
+ Function eFn) {
+ return aFn.apply(a);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _A
+ && Objects.equals(a, ((_A) other).a);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(a);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct5{" +
+ "a=" + a +
+ '}';
+ }
+ }
+
+ return new _A(a);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type B in a {@link CoProduct5}.
+ *
+ * @param b the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @return the wrapped value as a CoProduct5<A, B, C, D, E>
+ */
+ static CoProduct5 b(B b) {
+ class _B implements CoProduct5 {
+
+ private final B b;
+
+ private _B(B b) {
+ this.b = b;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn,
+ Function eFn) {
+ return bFn.apply(b);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _B
+ && Objects.equals(b, ((_B) other).b);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(b);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct5{" +
+ "b=" + b +
+ '}';
+ }
+ }
+
+ return new _B(b);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type C in a {@link CoProduct5}.
+ *
+ * @param c the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @return the wrapped value as a CoProduct5<A, B, C, D, E>
+ */
+ static CoProduct5 c(C c) {
+ class _C implements CoProduct5 {
+
+ private final C c;
+
+ private _C(C c) {
+ this.c = c;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn,
+ Function eFn) {
+ return cFn.apply(c);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _C
+ && Objects.equals(c, ((_C) other).c);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(c);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct5{" +
+ "c=" + c +
+ '}';
+ }
+ }
+
+ return new _C(c);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type D in a {@link CoProduct5}.
+ *
+ * @param d the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @return the wrapped value as a CoProduct5<A, B, C, D, E>
+ */
+ static CoProduct5 d(D d) {
+ class _D implements CoProduct5 {
+
+ private final D d;
+
+ private _D(D d) {
+ this.d = d;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn,
+ Function eFn) {
+ return dFn.apply(d);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _D
+ && Objects.equals(d, ((_D) other).d);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(d);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct5{" +
+ "d=" + d +
+ '}';
+ }
+ }
+
+ return new _D(d);
+ }
+
+ /**
+ * Static factory method for wrapping a value of type E in a {@link CoProduct5}.
+ *
+ * @param e the value
+ * @param a type parameter representing the first possible type of this coproduct
+ * @param a type parameter representing the second possible type of this coproduct
+ * @param a type parameter representing the third possible type of this coproduct
+ * @param a type parameter representing the fourth possible type of this coproduct
+ * @param a type parameter representing the fifth possible type of this coproduct
+ * @return the wrapped value as a CoProduct5<A, B, C, D, E>
+ */
+ static CoProduct5 e(E e) {
+ class _E implements CoProduct5 {
+
+ private final E e;
+
+ private _E(E e) {
+ this.e = e;
+ }
+
+ @Override
+ public R match(Function aFn, Function bFn,
+ Function cFn, Function dFn,
+ Function eFn) {
+ return eFn.apply(e);
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ return other instanceof _E
+ && Objects.equals(e, ((_E) other).e);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(e);
+ }
+
+ @Override
+ public String toString() {
+ return "CoProduct5{" +
+ "e=" + e +
+ '}';
+ }
+ }
+
+ return new _E(e);
+ }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Index.java b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Index.java
index 701cae229..12f1eeebd 100644
--- a/src/main/java/com/jnape/palatable/lambda/adt/hlist/Index.java
+++ b/src/main/java/com/jnape/palatable/lambda/adt/hlist/Index.java
@@ -38,6 +38,7 @@ private Index() {
*
* @param newElement the new value
* @param hList the HList
+ * @param the inferred tail type of the HList
* @return the updated HList
*/
public abstract L set(Target newElement, L hList);
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partition.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partition.java
new file mode 100644
index 000000000..57056430b
--- /dev/null
+++ b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Partition.java
@@ -0,0 +1,61 @@
+package com.jnape.palatable.lambda.functions.builtin.fn2;
+
+import com.jnape.palatable.lambda.adt.Either;
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn1;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+import java.util.Optional;
+import java.util.function.Function;
+
+import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
+import static com.jnape.palatable.lambda.functions.builtin.fn1.Id.id;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Filter.filter;
+import static com.jnape.palatable.lambda.functions.builtin.fn2.Map.map;
+
+/**
+ * Given an Iterable<A> as and a disjoint mapping function a -> Either<L,
+ * R>, return a {@link Tuple2} over the lazily unwrapped left L and right R values
+ * in the first and second slots, respectively. Note that while the tuple must be constructed eagerly, the left and
+ * right iterables contained therein are both lazy, so comprehension over infinite iterables is supported.
+ *
+ * @param A type contravariant to the input Iterable element type
+ * @param The output left Iterable element type, as well as the Either L type
+ * @param The output right Iterable element type, as well as the Either R type
+ * @see Either
+ */
+public final class Partition implements Fn2>, Iterable, Tuple2, Iterable>> {
+
+ private Partition() {
+ }
+
+ @Override
+ public Tuple2, Iterable> apply(Function> function,
+ Iterable as) {
+ Iterable> eithers = map(function, as);
+
+ Iterable lefts = unwrapRight(map(Either::invert, eithers));
+ Iterable rights = unwrapRight(map(id(), eithers));
+
+ return tuple(lefts, rights);
+ }
+
+ private Iterable unwrapRight(Iterable> eithers) {
+ return map(Optional::get, filter(Optional::isPresent, map(Either::toOptional, eithers)));
+ }
+
+ public static Partition partition() {
+ return new Partition<>();
+ }
+
+ public static Fn1, Tuple2, Iterable>> partition(
+ Function> function) {
+ return Partition.partition().apply(function);
+ }
+
+ public static Tuple2, Iterable> partition(
+ Function> function,
+ Iterable as) {
+ return Partition.partition(function).apply(as);
+ }
+}
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
index 15c17a796..f91b83aa4 100644
--- a/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
+++ b/src/main/java/com/jnape/palatable/lambda/functions/specialized/checked/CheckedFn1.java
@@ -13,7 +13,7 @@
* @see Fn1
*/
@FunctionalInterface
-public interface CheckedFn1 extends Fn1 {
+public interface CheckedFn1 extends Fn1