From 5c6a4d19c5bc74c4a5838dc643c3cc63a5560371 Mon Sep 17 00:00:00 2001
From: mrbackend <roy.brokvam@gmail.com>
Date: Sat, 27 Feb 2016 00:42:55 +0100
Subject: [PATCH 001/336] #235 fj.test.Gen.pick is broken

---
 quickcheck/src/main/java/fj/test/Gen.java     | 237 +++++++++++++++---
 quickcheck/src/test/java/fj/test/TestGen.java | 190 ++++++++++++++
 2 files changed, 396 insertions(+), 31 deletions(-)
 create mode 100644 quickcheck/src/test/java/fj/test/TestGen.java

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 9ff45dfe..2bac9cfc 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -1,25 +1,28 @@
 package fj.test;
 
-import static fj.Bottom.error;
-import fj.Effect;
 import fj.F;
 import fj.Function;
-import static fj.Function.flip;
-import static fj.Function.curry;
 import fj.P2;
-import static fj.P2.__1;
 import fj.Unit;
-import fj.F2;
-import static fj.data.Array.array;
+import fj.control.Trampoline;
+import fj.data.Array;
 import fj.data.List;
-import static fj.data.List.nil;
-import static fj.data.List.replicate;
 import fj.data.Option;
 import fj.function.Effect1;
 
+import static fj.Bottom.error;
+import static fj.Function.curry;
+import static fj.Function.flip;
 import static fj.Monoid.intAdditionMonoid;
 import static fj.Ord.intOrd;
-
+import static fj.P.lazy;
+import static fj.P2.__1;
+import static fj.control.Trampoline.pure;
+import static fj.control.Trampoline.suspend;
+import static fj.data.Array.array;
+import static fj.data.List.cons;
+import static fj.data.List.nil;
+import static fj.data.List.replicate;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
 
@@ -564,43 +567,215 @@ public static <A> Gen<List<A>> listOf1(final Gen<A> g) {
    * Returns a generator of lists that picks the given number of elements from the given list. If
    * the given number is less than zero or greater than the length of the given list, then the
    * returned generator will never produce a value.
+   * <p>
+   * Note: pick is synonymous with pickCombinationWithoutReplacement
+   *
+   * @param n  The number of elements to pick from the given list.
+   * @param as The list from which to pick elements.
+   * @return A generator of lists that picks the given number of elements from the given list.
+   */
+  @Deprecated
+  public static <A> Gen<List<A>> pick(int n, List<A> as) {
+    return pickCombinationWithoutReplacement(n, as);
+  }
+
+  /**
+   * Returns a generator of lists that picks the given number of elements from the given list. The selection is
+   * a combination without replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list will always contain its elements in the same order</li>
+   * <li>An element will never be picked more than once</li>
+   * </ul>
+   * <p>
+   * If the given number is less than zero or greater than the length of the given list, then the
+   * returned generator will never produce a value.
    *
    * @param n  The number of elements to pick from the given list.
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
    */
-  public static <A> Gen<List<A>> pick(final int n, final List<A> as) {
-    return n < 0 || n > as.length() ? Gen.<List<A>>fail() : sequenceN(n, choose(0, as.length() - 1)).map(new F<List<Integer>, List<A>>() {
-      public List<A> f(final List<Integer> is) {
-        List<A> r = nil();
+  public static <A> Gen<List<A>> pickCombinationWithoutReplacement(int n, List<A> as) {
+    int aLength = as.length();
+    return ((n >= 0) && (n <= aLength)) ?
+        parameterised(s -> r -> {
+          final class Tramp {
+
+            // Picks elements in constant stack space
+            private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALength) {
+              return suspend(lazy(() ->
+                  (remainN == 0) ?
+                      // We have picked N elements; stop
+                      pure(nil()) :
+                      // For M remaining elements of which N will be picked, pick remainAs.head() with probability N/M
+                      (r.choose(0, remainALength - 1) < remainN) ?
+                          tramp(remainAs.tail(), remainN - 1, remainALength - 1)
+                              .map(pickedTail -> cons(remainAs.head(), pickedTail)) :
+                          tramp(remainAs.tail(), remainN, remainALength - 1)));
+            }
 
-        List<Integer> iis = is.sort(intOrd);
-        List<P2<A, Integer>> aas = as.zipIndex();
+          }
+          return value(new Tramp().tramp(as, n, aLength).run());
+        }) :
+        fail();
+  }
 
-        //noinspection ForLoopWithMissingComponent
-        for(; iis.isNotEmpty() && aas.isNotEmpty(); aas = aas.tail())
-          if(iis.head().equals(aas.head()._2()))
-            iis = iis.tail();
-          else
-            r = r.snoc(aas.head()._1());
+  /**
+   * Returns a generator of lists that picks the given number of elements from the given list. The selection is
+   * a combination with replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list will always contain its elements in the same order</li>
+   * <li>Each element may be picked more than once</li>
+   * </ul>
+   * <p>
+   * If the given number is less than zero, then the returned generator will never produce a value. Note that,
+   * with replacement, the given number may be larger than the length of the given list.
+   *
+   * @param n  The number of elements to pick from the given list.
+   * @param as The list from which to pick elements.
+   * @return A generator of lists that picks the given number of elements from the given list.
+   */
+  public static <A> Gen<List<A>> pickCombinationWithReplacement(int n, List<A> as) {
+    Array<A> aArr = as.toArray();
+    return (n >= 0) ?
+        pick(indexPermutation(n, aArr.length()).map(indexes -> indexes.sort(intOrd)), aArr) :
+        fail();
+  }
 
-        return r;
-      }
-    });
+  /**
+   * Returns a generator of lists that picks the given number of elements from the given list. The selection is
+   * a permutation without replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list may contain its elements in any order</li>
+   * <li>An element will never be picked more than once</li>
+   * </ul>
+   * <p>
+   * If the given number is less than zero or greater than the length of the given list, then the
+   * returned generator will never produce a value.
+   *
+   * @param n  The number of elements to pick from the given list.
+   * @param as The list from which to pick elements.
+   * @return A generator of lists that picks the given number of elements from the given list.
+   */
+  public static <A> Gen<List<A>> pickPermutationWithoutReplacement(int n, List<A> as) {
+    return parameterised(s -> r ->
+        pickCombinationWithoutReplacement(n, as).map(combination -> {
+          // Shuffle combination using the Fisher-Yates algorithm
+          Array<A> aArr = combination.toArray();
+          int length = aArr.length();
+          for (int i = length - 1; i > 0; --i) {
+            int j = r.choose(0, i);
+            A tmp = aArr.get(i);
+            aArr.set(i, aArr.get(j));
+            aArr.set(j, tmp);
+          }
+          return aArr.toList();
+        }));
+  }
+
+  /**
+   * Returns a generator of lists that picks the given number of elements from the given list. The selection is
+   * a permutation with replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list may contain its elements in any order</li>
+   * <li>Each element may be picked more than once</li>
+   * </ul>
+   * <p>
+   * If the given number is less than zero, then the returned generator will never produce a value. Note that,
+   * with replacement, the given number may be larger than the length of the given list.
+   *
+   * @param n  The number of elements to pick from the given list.
+   * @param as The list from which to pick elements.
+   * @return A generator of lists that picks the given number of elements from the given list.
+   */
+  public static <A> Gen<List<A>> pickPermutationWithReplacement(int n, List<A> as) {
+    Array<A> aArr = as.toArray();
+    return (n >= 0) ?
+        pick(indexPermutation(n, aArr.length()), aArr) :
+        fail();
+  }
+
+  private static Gen<List<Integer>> indexPermutation(int n, int m) {
+    return sequenceN(n, choose(0, m - 1));
+  }
+
+  private static <A> Gen<List<A>> pick(Gen<List<Integer>> indexesGen, Array<A> as) {
+    return indexesGen.map(indexes ->
+        indexes.foldLeft((acc, index) -> cons(as.get(index), acc), List.<A>nil()).reverse());
   }
 
   /**
    * Returns a generator of lists that produces some of the values of the given list.
+   * <p>
+   * Note: someOf is synonymous with someCombinationWithoutReplacementOf
    *
    * @param as The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
-  public static <A> Gen<List<A>> someOf(final List<A> as) {
-    return choose(0, as.length()).bind(new F<Integer, Gen<List<A>>>() {
-      public Gen<List<A>> f(final Integer i) {
-        return pick(i, as);
-      }
-    });
+  @Deprecated
+  public static <A> Gen<List<A>> someOf(List<A> as) {
+    return someCombinationWithoutReplacementOf(as);
+  }
+
+  /**
+   * Returns a generator of lists that produces some of the values of the given list. The selection is
+   * a combination without replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list will always contain its elements in the same order</li>
+   * <li>An element will never be picked more than once</li>
+   * </ul>
+   *
+   * @param as The list from which to pick values.
+   * @return A generator of lists that produces some of the values of the given list.
+   */
+  public static <A> Gen<List<A>> someCombinationWithoutReplacementOf(List<A> as) {
+    return choose(0, as.length()).bind(n -> pickCombinationWithoutReplacement(n, as));
+  }
+
+  /**
+   * Returns a generator of lists that produces some of the values of the given list. The selection is
+   * a combination with replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list will always contain its elements in the same order</li>
+   * <li>Each element may be picked more than once</li>
+   * </ul>
+   *
+   * @param maxLength The maximum length of a generated list
+   * @param as        The list from which to pick values.
+   * @return A generator of lists that produces some of the values of the given list.
+   */
+  public static <A> Gen<List<A>> someCombinationWithReplacementOf(int maxLength, List<A> as) {
+    return choose(0, maxLength).bind(n -> pickCombinationWithReplacement(n, as));
+  }
+
+  /**
+   * Returns a generator of lists that produces some of the values of the given list. The selection is
+   * a permutation without replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list may contain its elements in any order</li>
+   * <li>An element will never be picked more than once</li>
+   * </ul>
+   *
+   * @param as The list from which to pick values.
+   * @return A generator of lists that produces some of the values of the given list.
+   */
+  public static <A> Gen<List<A>> somePermutationWithoutReplacementOf(List<A> as) {
+    return choose(0, as.length()).bind(n -> pickPermutationWithoutReplacement(n, as));
+  }
+
+  /**
+   * Returns a generator of lists that produces some of the values of the given list. The selection is
+   * a permutation with replacement of elements from the given list, i.e.
+   * <ul>
+   * <li>For any given selection, a generated list may contain its elements in any order</li>
+   * <li>Each element may be picked more than once</li>
+   * </ul>
+   *
+   * @param maxLength The maximum length of a generated list
+   * @param as        The list from which to pick values.
+   * @return A generator of lists that produces some of the values of the given list.
+   */
+  public static <A> Gen<List<A>> somePermutationWithReplacementOf(int maxLength, List<A> as) {
+    return choose(0, maxLength).bind(n -> pickPermutationWithReplacement(n, as));
   }
 
   /**
diff --git a/quickcheck/src/test/java/fj/test/TestGen.java b/quickcheck/src/test/java/fj/test/TestGen.java
new file mode 100644
index 00000000..5db6759c
--- /dev/null
+++ b/quickcheck/src/test/java/fj/test/TestGen.java
@@ -0,0 +1,190 @@
+package fj.test;
+
+import fj.data.List;
+import fj.function.Effect1;
+import org.junit.Test;
+
+import static fj.Ord.charOrd;
+import static fj.data.List.list;
+import static fj.data.List.range;
+import static fj.test.Gen.pickCombinationWithReplacement;
+import static fj.test.Gen.pickCombinationWithoutReplacement;
+import static fj.test.Gen.pickPermutationWithReplacement;
+import static fj.test.Gen.pickPermutationWithoutReplacement;
+import static fj.test.Rand.standard;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public final class TestGen {
+
+  private static final List<Character> AS = list('A', 'B', 'C');
+
+  @Test
+  public void testPickCombinationWithoutReplacement_none() {
+    Gen<List<Character>> instance = pickCombinationWithoutReplacement(0, AS);
+    testPick(100, instance, actual -> {
+      assertTrue(actual.isEmpty());
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithoutReplacement_one() {
+    Gen<List<Character>> instance = pickCombinationWithoutReplacement(1, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(1, actual.length());
+      assertTrue(AS.exists(a -> a.equals(actual.head())));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithoutReplacement_two() {
+    Gen<List<Character>> instance = pickCombinationWithoutReplacement(2, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(2, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> charOrd.isGreaterThan(a, l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithoutReplacement_three() {
+    Gen<List<Character>> instance = pickCombinationWithoutReplacement(3, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(3, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> charOrd.isGreaterThan(a, l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithReplacement_none() {
+    Gen<List<Character>> instance = pickCombinationWithReplacement(0, AS);
+    testPick(100, instance, actual -> {
+      assertTrue(actual.isEmpty());
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithReplacement_one() {
+    Gen<List<Character>> instance = pickCombinationWithReplacement(1, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(1, actual.length());
+      assertTrue(AS.exists(a -> a.equals(actual.head())));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithReplacement_two() {
+    Gen<List<Character>> instance = pickCombinationWithReplacement(2, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(2, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !charOrd.isLessThan(a, l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithReplacement_three() {
+    Gen<List<Character>> instance = pickCombinationWithReplacement(3, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(3, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !charOrd.isLessThan(a, l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickCombinationWithReplacement_four() {
+    Gen<List<Character>> instance = pickCombinationWithReplacement(4, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(4, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !charOrd.isLessThan(a, l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithoutReplacement_none() {
+    Gen<List<Character>> instance = pickPermutationWithoutReplacement(0, AS);
+    testPick(100, instance, actual -> {
+      assertTrue(actual.isEmpty());
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithoutReplacement_one() {
+    Gen<List<Character>> instance = pickPermutationWithoutReplacement(1, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(1, actual.length());
+      assertTrue(AS.exists(a -> a.equals(actual.head())));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithoutReplacement_two() {
+    Gen<List<Character>> instance = pickCombinationWithoutReplacement(2, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(2, actual.length());
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !a.equals(l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithoutReplacement_three() {
+    Gen<List<Character>> instance = pickPermutationWithoutReplacement(3, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(3, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+      assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !a.equals(l.head()))));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithReplacement_none() {
+    Gen<List<Character>> instance = pickPermutationWithReplacement(0, AS);
+    testPick(100, instance, actual -> {
+      assertTrue(actual.isEmpty());
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithReplacement_one() {
+    Gen<List<Character>> instance = pickPermutationWithReplacement(1, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(1, actual.length());
+      assertTrue(AS.exists(a -> a.equals(actual.head())));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithReplacement_two() {
+    Gen<List<Character>> instance = pickPermutationWithReplacement(2, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(2, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithReplacement_three() {
+    Gen<List<Character>> instance = pickPermutationWithReplacement(3, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(3, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+    });
+  }
+
+  @Test
+  public void testPickPermutationWithReplacement_four() {
+    Gen<List<Character>> instance = pickPermutationWithReplacement(4, AS);
+    testPick(100, instance, actual -> {
+      assertEquals(4, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+    });
+  }
+
+  private static <A> void testPick(int n, Gen<List<A>> instance, Effect1<List<A>> test) {
+    range(0, n).map(i -> instance.gen(0, standard)).foreachDoEffect(test::f);
+  }
+
+}

From 498e59b11dd9a9090c3b766bff3815645bd31ba2 Mon Sep 17 00:00:00 2001
From: mrbackend <roy.brokvam@gmail.com>
Date: Fri, 4 Mar 2016 03:23:34 +0100
Subject: [PATCH 002/336] fj.test.Rand.reseed() is broken (#237)

---
 .../src/main/java/fj/test/Property.java       |  14 +-
 quickcheck/src/main/java/fj/test/Rand.java    | 136 ++++++++++++------
 .../src/test/java/fj/test/TestRand.java       |  17 +++
 3 files changed, 113 insertions(+), 54 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 232911bd..18baccc3 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -184,7 +184,7 @@ else if (x.isFalsified()) {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator} and the given
+   * Checks this property using a {@link Rand#standard standard random generator} and the given
    * arguments to produce a result.
    *
    * @param minSuccessful The minimum number of successful tests before a result is reached.
@@ -226,7 +226,7 @@ public CheckResult check(final Rand r, final int minSize, final int maxSize) {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, 100 minimum
    * successful checks, 500 maximum discarded tests and the given arguments to produce a result.
    *
    * @param minSize The minimum size to use for checking.
@@ -239,7 +239,7 @@ public CheckResult check(final int minSize,
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, 100 minimum
    * successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
    *
    * @return A result after checking this property.
@@ -249,7 +249,7 @@ public CheckResult check() {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, the given minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, the given minimum
    * successful checks, 500 maximum discarded tests, minimum size of 0, maximum size of 100.
    *
    * @param minSuccessful The minimum number of successful tests before a result is reached.
@@ -272,7 +272,7 @@ public CheckResult minSuccessful(final Rand r, final int minSuccessful) {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, 100 minimum
    * successful checks, the given maximum discarded tests, minimum size of 0, maximum size of 100.
    *
    * @param maxDiscarded The maximum number of tests discarded because they did not satisfy
@@ -297,7 +297,7 @@ public CheckResult maxDiscarded(final Rand r, final int maxDiscarded) {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, 100 minimum
    * successful checks, 500 maximum discarded tests, the given minimum size, maximum size of 100.
    *
    * @param minSize The minimum size to use for checking.
@@ -320,7 +320,7 @@ public CheckResult minSize(final Rand r, final int minSize) {
   }
 
   /**
-   * Checks this property using a {@link Rand#Rand(F, F) standard random generator}, 100 minimum
+   * Checks this property using a {@link Rand#standard standard random generator}, 100 minimum
    * successful checks, 500 maximum discarded tests, minimum size of 0, the given maximum size.
    *
    * @param maxSize The maximum size to use for checking.
diff --git a/quickcheck/src/main/java/fj/test/Rand.java b/quickcheck/src/main/java/fj/test/Rand.java
index 500d04eb..567dba77 100644
--- a/quickcheck/src/main/java/fj/test/Rand.java
+++ b/quickcheck/src/main/java/fj/test/Rand.java
@@ -2,11 +2,13 @@
 
 import fj.F;
 import fj.data.Option;
-import static fj.data.Option.some;
 
+import java.util.Random;
+
+import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
-import java.util.Random;
 
 /**
  * A random number generator.
@@ -17,9 +19,17 @@ public final class Rand {
   private final F<Option<Long>, F<Integer, F<Integer, Integer>>> f;
   private final F<Option<Long>, F<Double, F<Double, Double>>> g;
 
-  private Rand(final F<Option<Long>, F<Integer, F<Integer, Integer>>> f, final F<Option<Long>, F<Double, F<Double, Double>>> g) {
+  // TODO Change to F<Long,Rand> when rand(f,g) is removed
+  private final Option<F<Long, Rand>> optOnReseed;
+
+  private Rand(
+      F<Option<Long>, F<Integer, F<Integer, Integer>>> f,
+      F<Option<Long>, F<Double, F<Double, Double>>> g,
+      Option<F<Long, Rand>> optOnReseed) {
+
     this.f = f;
     this.g = g;
+    this.optOnReseed = optOnReseed;
   }
 
   /**
@@ -74,65 +84,97 @@ public double choose(final double from, final double to) {
    * @param seed The seed of the new random generator.
    * @return A random generator with the given seed.
    */
-  public Rand reseed(final long seed) {
-    return new Rand(new F<Option<Long>, F<Integer, F<Integer, Integer>>>() {
-      public F<Integer, F<Integer, Integer>> f(final Option<Long> old) {
-        return new F<Integer, F<Integer, Integer>>() {
-          public F<Integer, Integer> f(final Integer from) {
-            return new F<Integer, Integer>() {
-              public Integer f(final Integer to) {
-                return f.f(some(seed)).f(from).f(to);
-              }
-            };
-          }
-        };
-      }
-    }, new F<Option<Long>, F<Double, F<Double, Double>>>() {
-      public F<Double, F<Double, Double>> f(final Option<Long> old) {
-        return new F<Double, F<Double, Double>>() {
-          public F<Double, Double> f(final Double from) {
-            return new F<Double, Double>() {
-              public Double f(final Double to) {
-                return g.f(some(seed)).f(from).f(to);
-              }
-            };
-          }
-        };
-      }
-    });
+  public Rand reseed(long seed) {
+    return optOnReseed.<Rand>option(
+        () -> {
+          throw new IllegalStateException("reseed() called on a Rand created with deprecated rand() method");
+        },
+        onReseed -> onReseed.f(seed));
   }
 
   /**
    * Constructs a random generator from the given functions that supply a range to produce a
    * result.
+   * <p>
+   * Calling {@link #reseed(long)} on an instance returned from this method will
+   * result in an exception being thrown. Use {@link #rand(F, F, F)} instead.
    *
    * @param f The integer random generator.
    * @param g The floating-point random generator.
    * @return A random generator from the given functions that supply a range to produce a result.
    */
-  public static Rand rand(final F<Option<Long>, F<Integer, F<Integer, Integer>>> f, final F<Option<Long>, F<Double, F<Double, Double>>> g) {
-    return new Rand(f, g);
+  // TODO Change Option<F<Long,Rand>> optOnReseed to F<Long,Road> onReseed when removing this method
+  @Deprecated
+  public static Rand rand(
+      F<Option<Long>, F<Integer, F<Integer, Integer>>> f,
+      F<Option<Long>, F<Double, F<Double, Double>>> g) {
+
+    return new Rand(f, g, none());
   }
 
+  /**
+   * Constructs a reseedable random generator from the given functions that supply a range to produce a
+   * result.
+   *
+   * @param f        The integer random generator.
+   * @param g        The floating-point random generator.
+   * @param onReseed Function to create a reseeded Rand.
+   * @return A random generator from the given functions that supply a range to produce a result.
+   */
+  public static Rand rand(
+      F<Option<Long>, F<Integer, F<Integer, Integer>>> f,
+      F<Option<Long>, F<Double, F<Double, Double>>> g,
+      F<Long, Rand> onReseed) {
 
-  private static final F<Long, Random> fr = new F<Long, Random>() {
-    public Random f(final Long x) {
-      return new Random(x);
-    }
-  };
+    return new Rand(f, g, some(onReseed));
+  }
 
   /**
    * A standard random generator that uses {@link Random}.
    */
-  public static final Rand standard = new Rand(seed -> from -> to -> {
-    final int min = min(from, to);
-    final int max = max(from, to);
-    final Random random = seed.map(fr).orSome(new Random());
-    return (int) ((random.nextLong() & Long.MAX_VALUE) % (1L + max - min)) + min;
-  }, seed -> from -> to -> {
-    final double min = min(from, to);
-    final double max = max(from, to);
-    final Random random = seed.map(fr).orSome(new Random());
-    return random.nextDouble() * (max - min) + min;
-  });
+  public static final Rand standard = createStandard(new Random());
+
+  private static Rand createStandard(Random defaultRandom) {
+    return rand(
+        optSeed -> from -> to ->
+            standardChooseInt(optSeed.<Random>option(() -> defaultRandom, Random::new), from, to),
+        optSeed -> from -> to ->
+            standardChooseDbl(optSeed.<Random>option(() -> defaultRandom, Random::new), from, to),
+        newSeed -> createStandard(new Random(newSeed)));
+  }
+
+  /*
+   * Returns a uniformly distributed value between min(from,to) (inclusive) and max(from,to) (inclusive).
+   */
+  private static int standardChooseInt(Random random, int from, int to) {
+    int result;
+    if (from != to) {
+      int min = min(from, to);
+      int max = max(from, to);
+      long range = (1L + max) - min;
+      long bound = Long.MAX_VALUE - (Long.MAX_VALUE % range);
+      long r = random.nextLong() & Long.MAX_VALUE;
+      while (r >= bound) {
+        // Ensure uniformity
+        r = random.nextLong() & Long.MAX_VALUE;
+      }
+      result = (int) ((r % range) + min);
+    } else {
+      result = from;
+    }
+    return result;
+  }
+
+  /*
+   * Returns a uniformly distributed value between min(from,to) (inclusive) and max(from,to) (exclusive)
+   *
+   * In theory, this differs from the choose() contract, which specifies a closed interval.
+   * In practice, the difference shouldn't matter.
+   */
+  private static double standardChooseDbl(Random random, double from, double to) {
+    double min = min(from, to);
+    double max = max(from, to);
+    return ((max - min) * random.nextDouble()) + min;
+  }
+
 }
diff --git a/quickcheck/src/test/java/fj/test/TestRand.java b/quickcheck/src/test/java/fj/test/TestRand.java
index 9df9639a..6c72b3b1 100644
--- a/quickcheck/src/test/java/fj/test/TestRand.java
+++ b/quickcheck/src/test/java/fj/test/TestRand.java
@@ -1,7 +1,10 @@
 package fj.test;
 
+import fj.Equal;
 import fj.Ord;
+import fj.data.List;
 import fj.data.Stream;
+import org.junit.Assert;
 import org.junit.Test;
 
 import static org.junit.Assert.assertTrue;
@@ -21,4 +24,18 @@ public void testRandLowHighInclusive() {
         assertTrue(s.head() == min && s.last() == max);
     }
 
+  @Test
+  public void testReseed() {
+    Rand rand1 = Rand.standard.reseed(42);
+    List<Integer> s1 =
+        List.range(0, 10).map(i -> rand1.choose(Integer.MIN_VALUE, Integer.MAX_VALUE));
+
+    Rand rand2 = rand1.reseed(42);
+    List<Integer> s2 =
+        List.range(0, 10).map(i -> rand2.choose(Integer.MIN_VALUE, Integer.MAX_VALUE));
+
+    assertTrue(s1.zip(s2).forall(p -> p._1().equals(p._2())));
+    Assert.assertFalse(s1.allEqual(Equal.intEqual));
+  }
+
 }

From 3548db113244002b619dd406ab428964e0324f2e Mon Sep 17 00:00:00 2001
From: mrbackend <roy.brokvam@gmail.com>
Date: Mon, 7 Mar 2016 23:20:24 +0100
Subject: [PATCH 003/336] #235 Changes after Code Review + added Gen.pickOne()

---
 quickcheck/src/main/java/fj/test/Gen.java     | 52 +++++++-----
 .../fj/test/{TestGen.java => GenTest.java}    | 84 +++++++++----------
 2 files changed, 74 insertions(+), 62 deletions(-)
 rename quickcheck/src/test/java/fj/test/{TestGen.java => GenTest.java} (59%)

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 2bac9cfc..0aa11adb 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -563,12 +563,24 @@ public static <A> Gen<List<A>> listOf1(final Gen<A> g) {
     return listOf(g, 1);
   }
 
+  /**
+   * Returns a generator that picks one element from the given list. If the given list is empty, then the
+   * returned generator will never produce a value.
+   *
+   * @param as The list from which to pick an element.
+   * @return A generator that picks an element from the given list.
+   */
+  public static <A> Gen<A> pickOne(List<A> as) {
+    // This is the fastest of the four; functionally, any of them would do
+    return wordOf(1, as).map(List::head);
+  }
+
   /**
    * Returns a generator of lists that picks the given number of elements from the given list. If
    * the given number is less than zero or greater than the length of the given list, then the
    * returned generator will never produce a value.
    * <p>
-   * Note: pick is synonymous with pickCombinationWithoutReplacement
+   * Note: pick is synonymous with combinationOf
    *
    * @param n  The number of elements to pick from the given list.
    * @param as The list from which to pick elements.
@@ -576,7 +588,7 @@ public static <A> Gen<List<A>> listOf1(final Gen<A> g) {
    */
   @Deprecated
   public static <A> Gen<List<A>> pick(int n, List<A> as) {
-    return pickCombinationWithoutReplacement(n, as);
+    return combinationOf(n, as);
   }
 
   /**
@@ -594,7 +606,7 @@ public static <A> Gen<List<A>> pick(int n, List<A> as) {
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
    */
-  public static <A> Gen<List<A>> pickCombinationWithoutReplacement(int n, List<A> as) {
+  public static <A> Gen<List<A>> combinationOf(int n, List<A> as) {
     int aLength = as.length();
     return ((n >= 0) && (n <= aLength)) ?
         parameterised(s -> r -> {
@@ -634,10 +646,10 @@ private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALeng
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
    */
-  public static <A> Gen<List<A>> pickCombinationWithReplacement(int n, List<A> as) {
+  public static <A> Gen<List<A>> selectionOf(int n, List<A> as) {
     Array<A> aArr = as.toArray();
     return (n >= 0) ?
-        pick(indexPermutation(n, aArr.length()).map(indexes -> indexes.sort(intOrd)), aArr) :
+        pick(indexWord(n, aArr.length()).map(indexes -> indexes.sort(intOrd)), aArr) :
         fail();
   }
 
@@ -656,9 +668,9 @@ public static <A> Gen<List<A>> pickCombinationWithReplacement(int n, List<A> as)
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
    */
-  public static <A> Gen<List<A>> pickPermutationWithoutReplacement(int n, List<A> as) {
+  public static <A> Gen<List<A>> permutationOf(int n, List<A> as) {
     return parameterised(s -> r ->
-        pickCombinationWithoutReplacement(n, as).map(combination -> {
+        combinationOf(n, as).map(combination -> {
           // Shuffle combination using the Fisher-Yates algorithm
           Array<A> aArr = combination.toArray();
           int length = aArr.length();
@@ -687,14 +699,14 @@ public static <A> Gen<List<A>> pickPermutationWithoutReplacement(int n, List<A>
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
    */
-  public static <A> Gen<List<A>> pickPermutationWithReplacement(int n, List<A> as) {
+  public static <A> Gen<List<A>> wordOf(int n, List<A> as) {
     Array<A> aArr = as.toArray();
     return (n >= 0) ?
-        pick(indexPermutation(n, aArr.length()), aArr) :
+        pick(indexWord(n, aArr.length()), aArr) :
         fail();
   }
 
-  private static Gen<List<Integer>> indexPermutation(int n, int m) {
+  private static Gen<List<Integer>> indexWord(int n, int m) {
     return sequenceN(n, choose(0, m - 1));
   }
 
@@ -706,14 +718,14 @@ private static <A> Gen<List<A>> pick(Gen<List<Integer>> indexesGen, Array<A> as)
   /**
    * Returns a generator of lists that produces some of the values of the given list.
    * <p>
-   * Note: someOf is synonymous with someCombinationWithoutReplacementOf
+   * Note: someOf is synonymous with someCombinationOf
    *
    * @param as The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
   @Deprecated
   public static <A> Gen<List<A>> someOf(List<A> as) {
-    return someCombinationWithoutReplacementOf(as);
+    return someCombinationOf(as);
   }
 
   /**
@@ -727,8 +739,8 @@ public static <A> Gen<List<A>> someOf(List<A> as) {
    * @param as The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
-  public static <A> Gen<List<A>> someCombinationWithoutReplacementOf(List<A> as) {
-    return choose(0, as.length()).bind(n -> pickCombinationWithoutReplacement(n, as));
+  public static <A> Gen<List<A>> someCombinationOf(List<A> as) {
+    return choose(0, as.length()).bind(n -> combinationOf(n, as));
   }
 
   /**
@@ -743,8 +755,8 @@ public static <A> Gen<List<A>> someCombinationWithoutReplacementOf(List<A> as) {
    * @param as        The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
-  public static <A> Gen<List<A>> someCombinationWithReplacementOf(int maxLength, List<A> as) {
-    return choose(0, maxLength).bind(n -> pickCombinationWithReplacement(n, as));
+  public static <A> Gen<List<A>> someSelectionOf(int maxLength, List<A> as) {
+    return choose(0, maxLength).bind(n -> selectionOf(n, as));
   }
 
   /**
@@ -758,8 +770,8 @@ public static <A> Gen<List<A>> someCombinationWithReplacementOf(int maxLength, L
    * @param as The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
-  public static <A> Gen<List<A>> somePermutationWithoutReplacementOf(List<A> as) {
-    return choose(0, as.length()).bind(n -> pickPermutationWithoutReplacement(n, as));
+  public static <A> Gen<List<A>> somePermutationOf(List<A> as) {
+    return choose(0, as.length()).bind(n -> permutationOf(n, as));
   }
 
   /**
@@ -774,8 +786,8 @@ public static <A> Gen<List<A>> somePermutationWithoutReplacementOf(List<A> as) {
    * @param as        The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
-  public static <A> Gen<List<A>> somePermutationWithReplacementOf(int maxLength, List<A> as) {
-    return choose(0, maxLength).bind(n -> pickPermutationWithReplacement(n, as));
+  public static <A> Gen<List<A>> someWordOf(int maxLength, List<A> as) {
+    return choose(0, maxLength).bind(n -> wordOf(n, as));
   }
 
   /**
diff --git a/quickcheck/src/test/java/fj/test/TestGen.java b/quickcheck/src/test/java/fj/test/GenTest.java
similarity index 59%
rename from quickcheck/src/test/java/fj/test/TestGen.java
rename to quickcheck/src/test/java/fj/test/GenTest.java
index 5db6759c..3bb723b8 100644
--- a/quickcheck/src/test/java/fj/test/TestGen.java
+++ b/quickcheck/src/test/java/fj/test/GenTest.java
@@ -7,29 +7,29 @@
 import static fj.Ord.charOrd;
 import static fj.data.List.list;
 import static fj.data.List.range;
-import static fj.test.Gen.pickCombinationWithReplacement;
-import static fj.test.Gen.pickCombinationWithoutReplacement;
-import static fj.test.Gen.pickPermutationWithReplacement;
-import static fj.test.Gen.pickPermutationWithoutReplacement;
+import static fj.test.Gen.selectionOf;
+import static fj.test.Gen.combinationOf;
+import static fj.test.Gen.wordOf;
+import static fj.test.Gen.permutationOf;
 import static fj.test.Rand.standard;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-public final class TestGen {
+public final class GenTest {
 
   private static final List<Character> AS = list('A', 'B', 'C');
 
   @Test
-  public void testPickCombinationWithoutReplacement_none() {
-    Gen<List<Character>> instance = pickCombinationWithoutReplacement(0, AS);
+  public void testCombinationOf_none() {
+    Gen<List<Character>> instance = combinationOf(0, AS);
     testPick(100, instance, actual -> {
       assertTrue(actual.isEmpty());
     });
   }
 
   @Test
-  public void testPickCombinationWithoutReplacement_one() {
-    Gen<List<Character>> instance = pickCombinationWithoutReplacement(1, AS);
+  public void testCombinationOf_one() {
+    Gen<List<Character>> instance = combinationOf(1, AS);
     testPick(100, instance, actual -> {
       assertEquals(1, actual.length());
       assertTrue(AS.exists(a -> a.equals(actual.head())));
@@ -37,8 +37,8 @@ public void testPickCombinationWithoutReplacement_one() {
   }
 
   @Test
-  public void testPickCombinationWithoutReplacement_two() {
-    Gen<List<Character>> instance = pickCombinationWithoutReplacement(2, AS);
+  public void testCombinationOf_two() {
+    Gen<List<Character>> instance = combinationOf(2, AS);
     testPick(100, instance, actual -> {
       assertEquals(2, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -47,8 +47,8 @@ public void testPickCombinationWithoutReplacement_two() {
   }
 
   @Test
-  public void testPickCombinationWithoutReplacement_three() {
-    Gen<List<Character>> instance = pickCombinationWithoutReplacement(3, AS);
+  public void testCombinationOf_three() {
+    Gen<List<Character>> instance = combinationOf(3, AS);
     testPick(100, instance, actual -> {
       assertEquals(3, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -57,16 +57,16 @@ public void testPickCombinationWithoutReplacement_three() {
   }
 
   @Test
-  public void testPickCombinationWithReplacement_none() {
-    Gen<List<Character>> instance = pickCombinationWithReplacement(0, AS);
+  public void testSelectionOf_none() {
+    Gen<List<Character>> instance = selectionOf(0, AS);
     testPick(100, instance, actual -> {
       assertTrue(actual.isEmpty());
     });
   }
 
   @Test
-  public void testPickCombinationWithReplacement_one() {
-    Gen<List<Character>> instance = pickCombinationWithReplacement(1, AS);
+  public void testSelectionOf_one() {
+    Gen<List<Character>> instance = selectionOf(1, AS);
     testPick(100, instance, actual -> {
       assertEquals(1, actual.length());
       assertTrue(AS.exists(a -> a.equals(actual.head())));
@@ -74,8 +74,8 @@ public void testPickCombinationWithReplacement_one() {
   }
 
   @Test
-  public void testPickCombinationWithReplacement_two() {
-    Gen<List<Character>> instance = pickCombinationWithReplacement(2, AS);
+  public void testSelectionOf_two() {
+    Gen<List<Character>> instance = selectionOf(2, AS);
     testPick(100, instance, actual -> {
       assertEquals(2, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -84,8 +84,8 @@ public void testPickCombinationWithReplacement_two() {
   }
 
   @Test
-  public void testPickCombinationWithReplacement_three() {
-    Gen<List<Character>> instance = pickCombinationWithReplacement(3, AS);
+  public void testSelectionOf_three() {
+    Gen<List<Character>> instance = selectionOf(3, AS);
     testPick(100, instance, actual -> {
       assertEquals(3, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -94,8 +94,8 @@ public void testPickCombinationWithReplacement_three() {
   }
 
   @Test
-  public void testPickCombinationWithReplacement_four() {
-    Gen<List<Character>> instance = pickCombinationWithReplacement(4, AS);
+  public void testSelectionOf_four() {
+    Gen<List<Character>> instance = selectionOf(4, AS);
     testPick(100, instance, actual -> {
       assertEquals(4, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -104,16 +104,16 @@ public void testPickCombinationWithReplacement_four() {
   }
 
   @Test
-  public void testPickPermutationWithoutReplacement_none() {
-    Gen<List<Character>> instance = pickPermutationWithoutReplacement(0, AS);
+  public void testPermutationOf_none() {
+    Gen<List<Character>> instance = permutationOf(0, AS);
     testPick(100, instance, actual -> {
       assertTrue(actual.isEmpty());
     });
   }
 
   @Test
-  public void testPickPermutationWithoutReplacement_one() {
-    Gen<List<Character>> instance = pickPermutationWithoutReplacement(1, AS);
+  public void testPermutationOf_one() {
+    Gen<List<Character>> instance = permutationOf(1, AS);
     testPick(100, instance, actual -> {
       assertEquals(1, actual.length());
       assertTrue(AS.exists(a -> a.equals(actual.head())));
@@ -121,8 +121,8 @@ public void testPickPermutationWithoutReplacement_one() {
   }
 
   @Test
-  public void testPickPermutationWithoutReplacement_two() {
-    Gen<List<Character>> instance = pickCombinationWithoutReplacement(2, AS);
+  public void testPermutationOf_two() {
+    Gen<List<Character>> instance = combinationOf(2, AS);
     testPick(100, instance, actual -> {
       assertEquals(2, actual.length());
       assertTrue(actual.tails().forall(l -> l.isEmpty() || l.tail().forall(a -> !a.equals(l.head()))));
@@ -130,8 +130,8 @@ public void testPickPermutationWithoutReplacement_two() {
   }
 
   @Test
-  public void testPickPermutationWithoutReplacement_three() {
-    Gen<List<Character>> instance = pickPermutationWithoutReplacement(3, AS);
+  public void testPermutationOf_three() {
+    Gen<List<Character>> instance = permutationOf(3, AS);
     testPick(100, instance, actual -> {
       assertEquals(3, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -140,16 +140,16 @@ public void testPickPermutationWithoutReplacement_three() {
   }
 
   @Test
-  public void testPickPermutationWithReplacement_none() {
-    Gen<List<Character>> instance = pickPermutationWithReplacement(0, AS);
+  public void testWordOf_none() {
+    Gen<List<Character>> instance = wordOf(0, AS);
     testPick(100, instance, actual -> {
       assertTrue(actual.isEmpty());
     });
   }
 
   @Test
-  public void testPickPermutationWithReplacement_one() {
-    Gen<List<Character>> instance = pickPermutationWithReplacement(1, AS);
+  public void testWordOf_one() {
+    Gen<List<Character>> instance = wordOf(1, AS);
     testPick(100, instance, actual -> {
       assertEquals(1, actual.length());
       assertTrue(AS.exists(a -> a.equals(actual.head())));
@@ -157,8 +157,8 @@ public void testPickPermutationWithReplacement_one() {
   }
 
   @Test
-  public void testPickPermutationWithReplacement_two() {
-    Gen<List<Character>> instance = pickPermutationWithReplacement(2, AS);
+  public void testWordOf_two() {
+    Gen<List<Character>> instance = wordOf(2, AS);
     testPick(100, instance, actual -> {
       assertEquals(2, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -166,8 +166,8 @@ public void testPickPermutationWithReplacement_two() {
   }
 
   @Test
-  public void testPickPermutationWithReplacement_three() {
-    Gen<List<Character>> instance = pickPermutationWithReplacement(3, AS);
+  public void testWordOf_three() {
+    Gen<List<Character>> instance = wordOf(3, AS);
     testPick(100, instance, actual -> {
       assertEquals(3, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -175,8 +175,8 @@ public void testPickPermutationWithReplacement_three() {
   }
 
   @Test
-  public void testPickPermutationWithReplacement_four() {
-    Gen<List<Character>> instance = pickPermutationWithReplacement(4, AS);
+  public void testWordOf_four() {
+    Gen<List<Character>> instance = wordOf(4, AS);
     testPick(100, instance, actual -> {
       assertEquals(4, actual.length());
       assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
@@ -184,7 +184,7 @@ public void testPickPermutationWithReplacement_four() {
   }
 
   private static <A> void testPick(int n, Gen<List<A>> instance, Effect1<List<A>> test) {
-    range(0, n).map(i -> instance.gen(0, standard)).foreachDoEffect(test::f);
+    range(0, n).map(ignore -> instance.gen(0, standard)).foreachDoEffect(test::f);
   }
 
 }

From a4695e352e115820e54551aa3d16b8ac50da22b9 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 8 May 2016 22:45:00 +1000
Subject: [PATCH 004/336] Upgraded Gradle to 2.13

---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index be138e88..a54a2d93 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip

From 5d45d6ac407d591c3404f88a27fbb4e46fed7dd5 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 9 May 2016 00:39:43 +1000
Subject: [PATCH 005/336] Updated jacoco version

---
 build.gradle | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 7a3b81cf..3bc75234 100644
--- a/build.gradle
+++ b/build.gradle
@@ -40,7 +40,9 @@ allprojects {
 
 
     jacoco {
-        toolVersion = "0.7.1.201405082137"
+//        toolVersion = "0.7.1.201405082137"
+        toolVersion = "0.7.6.201602180812"
+
     }
 
 	defaultTasks "build"

From acadf6afd4276ae33377648cd61fa6a6c1ed6206 Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Wed, 11 May 2016 22:18:10 +1000
Subject: [PATCH 006/336] Add some optics for Option

---
 core/src/main/java/fj/data/Option.java | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index c9f9f9f2..476d38db 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -19,6 +19,8 @@
 import fj.Equal;
 import fj.Ord;
 import fj.Hash;
+import fj.data.optic.Prism;
+import fj.data.optic.PPrism;
 import static fj.Function.*;
 import static fj.P.p;
 import static fj.Unit.unit;
@@ -30,6 +32,8 @@
 import static fj.data.Validation.parseInt;
 import static fj.data.Validation.parseLong;
 import static fj.data.Validation.parseShort;
+import static fj.data.optic.Prism.prism;
+import static fj.data.optic.PPrism.pPrism;
 import static fj.Show.optionShow;
 
 import java.util.Collection;
@@ -883,4 +887,34 @@ public static <A> F<Option<Option<A>>, Option<A>> join() {
    * A function that parses a string to a short.
    */
   public static final F<String, Option<Short>> parseShort = s -> parseShort(s).toOption();
+
+  public static final class Optic {
+
+    private Optic() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * None prism
+     */
+    public static <A> Prism<Option<A>, Unit> none() {
+      return prism(o -> o.option(Option.some(Unit.unit()), a -> Option.none()), u -> Option.none());
+    }
+
+    /**
+     * Polymorphic Some prism
+     */
+    public static <A, B> PPrism<Option<A>, Option<B>, A, B> pSome() {
+      return pPrism(o -> o.<Either<Option<B>, A>>map(Either::right).orSome(Either.left(Option.none())), Option::some);
+    }
+
+    /**
+     * Monomorphic Some prism
+     */
+    public static <A> Prism<Option<A>, A> some() {
+      return new Prism<>(pSome());
+    }
+
+  }
+
 }

From 5f1d7ad6660745784987d6e219747ca8d1d8e5e4 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Thu, 12 May 2016 11:52:29 +1000
Subject: [PATCH 007/336] Add property checks for Option optics

---
 props-core-scalacheck/src/main/scala/fj/package.scala     | 8 +++++---
 .../src/test/scala/fj/data/CheckOption.scala              | 8 ++++++++
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/props-core-scalacheck/src/main/scala/fj/package.scala b/props-core-scalacheck/src/main/scala/fj/package.scala
index 5a3b9bfc..78afe491 100644
--- a/props-core-scalacheck/src/main/scala/fj/package.scala
+++ b/props-core-scalacheck/src/main/scala/fj/package.scala
@@ -1,5 +1,5 @@
 import fj.Equal
-import fj.data.List
+import fj.data.{Option, List}
 package object fj {
   implicit def Function1F[A, B](g: A => B): F[A, B] = new F[A, B] {
     def f(a: A) = g(a)
@@ -16,9 +16,11 @@ package object fj {
   implicit def intEqual: Equal[Int] = Equal.equal({(i1:Int, i2:Int) => Boolean.box((i1 == i2))})
 
   implicit def unitEqual: Equal[Unit] = Equal.anyEqual()
-  
+
   implicit def listEqual[A](implicit aEq: Equal[A]): Equal[List[A]] = Equal.listEqual(aEq)
-  
+
+  implicit def optionEqual[A](implicit aEq: Equal[A]): Equal[Option[A]] = Equal.optionEqual(aEq)
+
   implicit def p2Equal[A, B](implicit aEq: Equal[A], bEq: Equal[B]): Equal[P2[A, B]] = Equal.p2Equal(aEq, bEq)
   
 }
\ No newline at end of file
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckOption.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckOption.scala
index 18d2cdf2..13059d3f 100644
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckOption.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckOption.scala
@@ -1,9 +1,11 @@
 package fj
 package data
 
+import fj.data.optic.PrismLaws
 import org.scalacheck.Prop._
 import ArbitraryOption.arbitraryOption
 import ArbitraryP.arbitraryP1
+import ArbitraryUnit._
 import Equal.{optionEqual, stringEqual}
 import Unit.unit
 import Option.{none, some, join}
@@ -84,4 +86,10 @@ object CheckOption extends Properties("Option") {
     a.isNone || optionEqual(stringEqual).eq(
       join(a),
       a.some))
+
+  property("Optic.pSome") = PrismLaws[Option[String], String](Option.Optic.pSome())
+
+  property("Optic.some") = PrismLaws[Option[String], String](Option.Optic.some())
+
+  property("Optic.none") = PrismLaws[Option[Unit], Unit](Option.Optic.none())
 }

From 72f3e761d6c1afc209990d4fc9618e53af634cd1 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Thu, 12 May 2016 15:57:34 +1000
Subject: [PATCH 008/336] Add "as" and "voided" IO functions

---
 core/src/main/java/fj/data/IOFunctions.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index bb2d7de1..8d766d15 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -339,6 +339,14 @@ public B run() throws IOException {
         };
     }
 
+    public static final <A, B> IO<B> as(final IO<A> io, final B b) {
+        return map(io, ignored -> b);
+    }
+
+    public static final <A> IO<Unit> voided(final IO <A> io) {
+        return as(io, Unit.unit());
+    }
+
     public static final <A, B> IO<B> bind(final IO<A> io, final F<A, IO<B>> f) {
         return new IO<B>() {
             @Override

From 8703a75974b9fa99127660bf70c653c180bb7dc7 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Thu, 12 May 2016 16:12:27 +1000
Subject: [PATCH 009/336] Add "when" and "unless" to IOFunctions

---
 core/src/main/java/fj/data/IOFunctions.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 8d766d15..9136311b 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -356,6 +356,14 @@ public B run() throws IOException {
         };
     }
 
+    public static final IO<Unit> when(final IO<Unit> io, final Boolean b) {
+        return b ? io : ioUnit;
+    }
+
+    public static final IO<Unit> unless(final IO<Unit> io, final Boolean b) {
+        return when(io, !b);
+    }
+
     /**
      * Evaluate each action in the sequence from left to right, and collect the results.
      */

From 42ee23dca237d739036e5082f682285512da326e Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Fri, 13 May 2016 11:19:35 +1000
Subject: [PATCH 010/336] Swap arguments to "when" and "unless"

---
 core/src/main/java/fj/data/IOFunctions.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 9136311b..dce5d0af 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -356,12 +356,12 @@ public B run() throws IOException {
         };
     }
 
-    public static final IO<Unit> when(final IO<Unit> io, final Boolean b) {
+    public static final IO<Unit> when(final Boolean b, final IO<Unit> io) {
         return b ? io : ioUnit;
     }
 
-    public static final IO<Unit> unless(final IO<Unit> io, final Boolean b) {
-        return when(io, !b);
+    public static final IO<Unit> unless(final Boolean b, final IO<Unit> io) {
+        return when(!b, io);
     }
 
     /**

From 6892c93a687b1df1f523f6e6f9e4ab431df72ac2 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Fri, 13 May 2016 11:20:15 +1000
Subject: [PATCH 011/336] Add a Semigroup for IO

---
 core/src/main/java/fj/Semigroup.java | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index e1e4fdf7..0da2cd77 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -2,6 +2,8 @@
 
 import fj.data.Array;
 import fj.data.List;
+import fj.data.IO;
+import fj.data.IOFunctions;
 import fj.data.Natural;
 import fj.data.NonEmptyList;
 import fj.data.Option;
@@ -355,6 +357,13 @@ public static <A, B> Semigroup<P2<A, B>> p2Semigroup(final Semigroup<A> sa, fina
     return semigroup((a1, a2) -> P.lazy(() -> sa.sum(a1._1(), a2._1()), () -> sb.sum(a1._2(), a2._2())));
   }
 
+  /**
+   * A semigroup for IO values.
+   */
+  public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
+      return semigroup((a1, a2) -> IOFunctions.liftM2(a1, a2, sa::sum));
+  }
+
   /**
    * A semigroup for the Unit value.
    */

From f89381d5aeed29ef553b8bb766999036ed2f465d Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Fri, 13 May 2016 11:31:56 +1000
Subject: [PATCH 012/336] Add "first" and "last" semigroups

---
 core/src/main/java/fj/Semigroup.java | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 0da2cd77..18172990 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -264,6 +264,20 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   public static final Semigroup<StringBuilder> stringBuilderSemigroup =
       semigroup((s1, s2) -> new StringBuilder(s1).append(s2));
 
+  /**
+   * A semigroup which always uses the "first" (left-hand side) value.
+   */
+  public static <A> Semigroup<A> firstSemigroup() {
+      return semigroup((a1, a2) -> a1);
+  }
+
+  /**
+   * A semigroup which always uses the "last" (right-hand side) value.
+   */
+  public static <A> Semigroup<A> lastSemigroup() {
+    return semigroup((a1, a2) -> a2);
+  }
+
   /**
    * A semigroup for functions.
    *

From 637c18c9f7c819f6cd52486ecd7cdf07838048cb Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Fri, 13 May 2016 20:23:47 +1000
Subject: [PATCH 013/336] Add a Monoid for Unit

---
 core/src/main/java/fj/Monoid.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 40d6e8e7..0d70c481 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -384,6 +384,11 @@ public static <A> Monoid<Array<A>> arrayMonoid() {
     return monoid(Semigroup.<A>arraySemigroup(), Array.<A>empty());
   }
 
+  /**
+   * A monoid for the Unit value.
+   */
+  public static final Monoid<Unit> unitMonoid = monoid(Semigroup.unitSemigroup, Unit.unit());
+
   /**
    * A monoid for sets.
    *

From 77f45b6005bcc2208311c629b86e49bbe8e0df71 Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Fri, 13 May 2016 20:23:54 +1000
Subject: [PATCH 014/336] Add a Monoid for IO

---
 core/src/main/java/fj/Monoid.java | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 0d70c481..c2214748 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -4,6 +4,8 @@
 import static fj.Function.flip;
 import fj.data.Array;
 import fj.data.List;
+import fj.data.IO;
+import fj.data.IOFunctions;
 import fj.data.Natural;
 import fj.data.Option;
 import fj.data.Set;
@@ -384,6 +386,13 @@ public static <A> Monoid<Array<A>> arrayMonoid() {
     return monoid(Semigroup.<A>arraySemigroup(), Array.<A>empty());
   }
 
+  /**
+   * A monoid for IO values.
+   */
+  public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
+    return monoid(Semigroup.ioSemigroup(ma.semigroup()), IOFunctions.unit(ma.zero()));
+  }
+
   /**
    * A monoid for the Unit value.
    */

From 36a0a784f03730191cf5970433a4e32a8d6c999d Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 14 May 2016 00:08:41 +0200
Subject: [PATCH 015/336] Update to latest retrolambda release and gradle
 plugin. Retro lambda 2.3.0 reduce by ~5% the number of generated methods.

---
 build.gradle | 6 +++---
 lib.gradle   | 3 +++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 3bc75234..2744cd00 100644
--- a/build.gradle
+++ b/build.gradle
@@ -7,7 +7,8 @@ ext {
 buildscript {
     ext {
 		uptodateVersion = "1.6.0"
-        retrolambdaVersion = "3.2.0"
+        retrolambdaPluginVersion = "3.2.5"
+        retrolambdaVersion = "2.3.0"
     }
 
     repositories {
@@ -18,12 +19,11 @@ buildscript {
 
     dependencies {
         classpath "com.ofg:uptodate-gradle-plugin:$uptodateVersion"
-        classpath "me.tatarka:gradle-retrolambda:$retrolambdaVersion"
+        classpath "me.tatarka:gradle-retrolambda:$retrolambdaPluginVersion"
         classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.6.3'
     }
 }
 
-
 apply plugin: "jacoco"
 apply plugin: 'com.github.kt3k.coveralls'
 
diff --git a/lib.gradle b/lib.gradle
index dbaebe4d..5b84e98b 100644
--- a/lib.gradle
+++ b/lib.gradle
@@ -90,6 +90,9 @@ void configureRetroLambda(boolean useRetroLambda, String newJdkEnvVar, String ol
             oldJdk System.getenv(oldJdkEnvVar)
             javaVersion retroLambdaTarget
         }
+        dependencies {
+            retrolambdaConfig "net.orfjackal.retrolambda:retrolambda:$retrolambdaVersion"
+        }
     }
 }
 

From c7785406ed74b4f31eedb336acf7ab8334154dd7 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Mon, 16 May 2016 09:02:42 +1000
Subject: [PATCH 016/336] Fix backwards List#traverseIO

Fixes #248
---
 core/src/main/java/fj/data/List.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 2d6f7683..36b005f1 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -640,7 +640,7 @@ public <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
 
     public <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
         return this.foldRight(
-                (a, acc) -> IOFunctions.bind(acc, (bs) -> IOFunctions.map(f.f(a), b -> bs.cons(b))),
+                (a, acc) -> IOFunctions.bind(f.f(a), b -> IOFunctions.map(acc, bs -> bs.cons(b))),
                 IOFunctions.unit(List.<B>nil())
         );
     }

From c1565d7b986f5111fb73a412dab0ec4f02742543 Mon Sep 17 00:00:00 2001
From: Brian McKenna <bmckenna@atlassian.com>
Date: Mon, 16 May 2016 16:19:39 +1000
Subject: [PATCH 017/336] Add "ignored" Optional optic

---
 core/src/main/java/fj/data/optic/Optional.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/src/main/java/fj/data/optic/Optional.java b/core/src/main/java/fj/data/optic/Optional.java
index de63fc2d..ed737cf0 100644
--- a/core/src/main/java/fj/data/optic/Optional.java
+++ b/core/src/main/java/fj/data/optic/Optional.java
@@ -171,6 +171,10 @@ public static <S> Optional<S, S> id() {
     return new Optional<>(POptional.pId());
   }
 
+  public static <S, A> Optional<S, A> ignored() {
+    return optional(s -> Option.none(), a -> s -> s);
+  }
+
   public static final <S, A> Optional<S, A> optional(final F<S, Option<A>> getOption, final F<A, F<S, S>> set) {
     return new Optional<>(new POptional<S, S, A, A>() {
 

From 77258ff71237f5d88aad1f833ab799f7021570f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabian=20Kr=C3=A4mer?= <fakraemer@atlassian.com>
Date: Mon, 23 May 2016 18:44:00 +1000
Subject: [PATCH 018/336] Fix eager IOW.bind

---
 core/src/main/java/fj/data/IOW.java | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index 5364f49e..8e8960d7 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -25,20 +25,11 @@ public A run() throws IOException {
         return io.run();
     }
 
-    public <B> IOW<B> map(F<A, B> f) {
-        return lift(() -> f.f(io.run()));
-    }
+    public <B> IOW<B> map(F<A, B> f) { return lift(IOFunctions.map(io, f)); }
 
-    public <B> IOW<B> bind(F<A, IO<B>> f) throws IOException {
-        return lift(f.f(io.run()));
-    }
+    public <B> IOW<B> bind(F<A, IO<B>> f) { return lift(IOFunctions.bind(io, f)); }
 
-    public <B> IOW<B> append(IO<B> iob) {
-        return lift(() -> {
-            io.run();
-            return iob.run();
-        });
-    }
+    public <B> IOW<B> append(IO<B> iob) { return lift(IOFunctions.append(io, iob)); }
 
     public IOW<LazyString> getContents() {
         return lift(() -> IOFunctions.getContents().run());

From 47b58b8f1c09ce2f9d875412c6f1c4213cd2dd90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabian=20Kr=C3=A4mer?= <fakraemer@atlassian.com>
Date: Tue, 24 May 2016 11:43:41 +1000
Subject: [PATCH 019/336] Provide an IO walkthrough example demonstrating basic
 composition

---
 core/src/main/java/fj/data/IOFunctions.java   |  7 ++
 core/src/main/java/fj/data/IOW.java           |  4 +
 demo/src/main/java/fj/demo/IOWalkthrough.java | 83 +++++++++++++++++++
 3 files changed, 94 insertions(+)
 create mode 100644 demo/src/main/java/fj/demo/IOWalkthrough.java

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index dce5d0af..d53caf9a 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -495,6 +495,13 @@ public static IO<Unit> stdoutPrintln(final String s) {
         };
     }
 
+    public static IO<Unit> stdoutPrint(final String s) {
+        return () -> {
+            System.out.print(s);
+            return Unit.unit();
+        };
+    }
+
     public static IO<LazyString> getContents() {
         Stream<IO<Integer>> s = Stream.<IO<Integer>>repeat(() -> (int) stdinBufferedReader.read());
         return IOFunctions.map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> {
diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index 8e8960d7..4b146cde 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -25,6 +25,10 @@ public A run() throws IOException {
         return io.run();
     }
 
+    public SafeIO<Validation<IOException, A>> safe() {
+        return IOFunctions.toSafeValidation(io);
+    }
+
     public <B> IOW<B> map(F<A, B> f) { return lift(IOFunctions.map(io, f)); }
 
     public <B> IOW<B> bind(F<A, IO<B>> f) { return lift(IOFunctions.bind(io, f)); }
diff --git a/demo/src/main/java/fj/demo/IOWalkthrough.java b/demo/src/main/java/fj/demo/IOWalkthrough.java
new file mode 100644
index 00000000..85c9a7c9
--- /dev/null
+++ b/demo/src/main/java/fj/demo/IOWalkthrough.java
@@ -0,0 +1,83 @@
+package fj.demo;
+
+import fj.F;
+import fj.F1Functions;
+import fj.F1W;
+import fj.Unit;
+import fj.data.IO;
+import fj.data.IOFunctions;
+import fj.data.IOW;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import static fj.data.IOFunctions.stdinReadLine;
+import static fj.data.IOFunctions.stdoutPrint;
+import static fj.data.IOFunctions.stdoutPrintln;
+import static fj.data.IOFunctions.toSafeValidation;
+
+/**
+ * Demonstrates how to use <code>IO</code> and basic function composition.
+ */
+public class IOWalkthrough {
+    public static void main(String[] args) {
+
+        // IO is just a container to defer a computation (lazy), with the intention to encapsulate computations that either
+        // consume and/or produce side-effects
+        // the computation is not (yet) executed on creation hence it can be treated like a value
+
+        final IO<Unit> askName = () -> {
+            System.out.println("Hi, what's your name?");
+            return Unit.unit();
+        };
+
+        // fj.data.IOFunctions contains a lot of convenience functions regarding IO, the above example could be rewritten with IOFunctions.stdoutPrintln
+        // we now create an IO value to prompt for the name if executed
+
+        IO<Unit> promptName = IOFunctions.stdoutPrint("Name: ");
+
+        // we can compose these two values with fj.data.IOFunctions.append, since they both are not interested in any runtime value
+
+        IO<Unit> askAndPromptName = IOFunctions.append(askName, promptName);
+
+        // now we create an IO value to read a line from stdin
+
+        final IO<String> readName = () -> new BufferedReader(new InputStreamReader(System.in)).readLine();
+
+        // this is the same as IOFunctions.stdinReadLine()
+
+        // now we create a function which takes a string, upper cases it and creates an IO value that would print the upper cased string if executed
+
+        final F<String, IO<Unit>> upperCaseAndPrint = F1Functions.<String, IO<Unit>, String>o(IOFunctions::stdoutPrintln).f(s -> s.toUpperCase());
+
+        // we now want to compose reading the name with printing it, for that we need to have access to the runtime value that is returned when the
+        // IO value for read is executed, hence we use fj.data.IOFunctions.bind instead of fj.data.IOFunctions.append
+
+        final IO<Unit> readAndPrintUpperCasedName = IOFunctions.bind(readName, upperCaseAndPrint);
+
+        // so append is really just a specialised form of bind, ignoring the runtime value of the IO execution that was composed before us
+
+        final IO<Unit> program = IOFunctions.bind(askAndPromptName, ignored -> readAndPrintUpperCasedName);
+
+        // this is the same as writing IOFunctions.append(askAndPromptName, readAndPrintUpperCasedName)
+
+        // we have recorded the entire program, but have not run anything yet
+        // now we get to the small dirty part at the end of our program where we actually execute it
+        // we can either choose to just call program.run(), which allows the execution to escape
+        // or we use safe to receive an fj.data.Either with the potential exception on the left side
+
+        toSafeValidation(program).run().on((IOException e) -> { e.printStackTrace(); return Unit.unit(); });
+
+        // doing function composition like this can be quite cumbersome, since you will end up nesting parenthesis unless you flatten it out by
+        // assigning the functions to variables like above, but you can use the fj.F1W syntax wrapper for composing single-argument functions and fj.data.IOW
+        // for composing IO values instead, the entire program can be written like so:
+
+        IOW.lift(stdoutPrintln("What's your name again?"))
+                .append(stdoutPrint("Name: "))
+                .append(stdinReadLine())
+                .bind(F1W.lift((String s) -> s.toUpperCase()).andThen(IOFunctions::stdoutPrintln))
+                .safe().run().on((IOException e) -> { e.printStackTrace(); return Unit.unit(); });
+    }
+}
+

From 369986e68bbcd9fa37f9a807e5b3b67dc02980b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabian=20Kr=C3=A4mer?= <fakraemer@atlassian.com>
Date: Tue, 24 May 2016 15:24:53 +1000
Subject: [PATCH 020/336] Use instance method reference in IOWalkthrough

---
 demo/src/main/java/fj/demo/IOWalkthrough.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/demo/src/main/java/fj/demo/IOWalkthrough.java b/demo/src/main/java/fj/demo/IOWalkthrough.java
index 85c9a7c9..609d2502 100644
--- a/demo/src/main/java/fj/demo/IOWalkthrough.java
+++ b/demo/src/main/java/fj/demo/IOWalkthrough.java
@@ -49,7 +49,7 @@ public static void main(String[] args) {
 
         // now we create a function which takes a string, upper cases it and creates an IO value that would print the upper cased string if executed
 
-        final F<String, IO<Unit>> upperCaseAndPrint = F1Functions.<String, IO<Unit>, String>o(IOFunctions::stdoutPrintln).f(s -> s.toUpperCase());
+        final F<String, IO<Unit>> upperCaseAndPrint = F1Functions.<String, IO<Unit>, String>o(IOFunctions::stdoutPrintln).f(String::toUpperCase);
 
         // we now want to compose reading the name with printing it, for that we need to have access to the runtime value that is returned when the
         // IO value for read is executed, hence we use fj.data.IOFunctions.bind instead of fj.data.IOFunctions.append

From 74b0fe43f8acd42ad99aaeadd2cf9bd1192d5e8b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 15 Feb 2016 07:33:51 +1000
Subject: [PATCH 021/336] Changes to release 4.5

---
 build.gradle      | 4 ++--
 gradle.properties | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 2744cd00..e11b2274 100644
--- a/build.gradle
+++ b/build.gradle
@@ -48,7 +48,7 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = true
+        isSnapshot = false
         fjBaseVersion = "4.6"
 
         snapshotAppendix = "-SNAPSHOT"
@@ -56,7 +56,7 @@ allprojects {
         fjConsumeVersion = "4.5"
 
         signModule = false
-        useRetroLambda = false
+        useRetroLambda = true
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
diff --git a/gradle.properties b/gradle.properties
index d4552a30..07c2b60c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = false
+signingEnabled = true

From ff6c580256922884d41c867ef3888737cfe68308 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 15 Feb 2016 07:35:36 +1000
Subject: [PATCH 022/336] Increase version to 4.6-SNAPSHOT

---
 build.gradle      | 4 ++--
 gradle.properties | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index e11b2274..2744cd00 100644
--- a/build.gradle
+++ b/build.gradle
@@ -48,7 +48,7 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = false
+        isSnapshot = true
         fjBaseVersion = "4.6"
 
         snapshotAppendix = "-SNAPSHOT"
@@ -56,7 +56,7 @@ allprojects {
         fjConsumeVersion = "4.5"
 
         signModule = false
-        useRetroLambda = true
+        useRetroLambda = false
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
diff --git a/gradle.properties b/gradle.properties
index 07c2b60c..d4552a30 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = true
+signingEnabled = false

From 61708ee4b0a079066271cee038ba5abbe4913470 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Fri, 4 Mar 2016 08:12:36 +0100
Subject: [PATCH 023/336] Remove deprecated shallowEqualsO

---
 core/src/main/java/fj/Equal.java | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 60fcb86d..23ceffd3 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -544,25 +544,6 @@ public static <K, V> Equal<TreeMap<K, V>> treeMapEqual(Equal<K> k, Equal<V> v) {
   public static <A, B> Equal<Writer<A, B>> writerEqual(Equal<A> eq1, Equal<B> eq2) {
     return equal(w1 -> w2 -> p2Equal(eq1, eq2).eq(w1.run(), w2.run()));
   }
-
-  /**
-   * @return Returns none if no equality can be determined by checking the nullity and reference values, else the equality
-   * @deprecated see issue #122.
-   */
-  @Deprecated
-  public static Option<Boolean> shallowEqualsO(Object o1, Object o2) {
-    if (o1 == null && o2 == null) {
-      return Option.some(true);
-    } else if (o1 == o2) {
-      return Option.some(true);
-    } else if (o1 != null && o2 != null) {
-      java.lang.Class<?> c = o1.getClass();
-      // WARNING: this may return some(false) for two instance of same type (and thus comparable) but of different class (typicaly anonymous class instance).
-      return c.isInstance(o2) ? Option.none() : Option.some(false);
-    } else {
-      return Option.some(false);
-    }
-  }
   
   /**
    * Helper method to implement {@link Object#equals(Object)} correctly. DO NOT USE it for any other purpose.

From 5e6da6f8673ed97a2c99866662f757c2b5088e8c Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Fri, 4 Mar 2016 22:01:00 +0100
Subject: [PATCH 024/336] Deprecate toJavaArray: unsafe

---
 core/src/main/java/fj/data/Array.java     | 9 ++++++++-
 core/src/main/java/fj/data/List.java      | 9 ++++++++-
 core/src/main/java/fj/data/Stream.java    | 9 ++++++++-
 core/src/test/java/fj/data/ArrayTest.java | 9 +++++----
 4 files changed, 29 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index f24e529c..ea8c7312 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -128,7 +128,14 @@ public Object[] array() {
     return copyOf(a, a.length);
   }
 
-  @SuppressWarnings("unchecked")
+  /**
+   * To be removed in future release:
+   * affectation of the result of this method to a non generic array
+   * will result in runtime error (ClassCastException).
+   *
+   * @deprecated use {@link #array(Class)}
+   */
+  @Deprecated
   public A[] toJavaArray() {
     return (A[]) array();
   }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 36b005f1..4920e021 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -211,7 +211,14 @@ public final Object[] toArrayObject() {
     return a;
   }
 
-  @SuppressWarnings("unchecked")
+  /**
+   * To be removed in future release:
+   * affectation of the result of this method to a non generic array
+   * will result in runtime error (ClassCastException).
+   *
+   * @deprecated use {@link #array(Class)}
+   */
+  @Deprecated
   public final A[] toJavaArray() {
     return (A[]) toArrayObject();
   }
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index d21c2f15..2e7ca879 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -916,7 +916,14 @@ public final Option<A> toOption() {
     return isEmpty() ? Option.<A>none() : some(head());
   }
 
-  @SuppressWarnings({"unchecked", "UnnecessaryFullyQualifiedName"})
+  /**
+   * To be removed in future release:
+   * affectation of the result of this method to a non generic array
+   * will result in runtime error (ClassCastException).
+   *
+   * @deprecated use {@link #array(Class)}
+   */
+  @Deprecated
   public final A[] toJavaArray() {
     final A[] array = (A[]) new Object[length()];
     int i = 0;
diff --git a/core/src/test/java/fj/data/ArrayTest.java b/core/src/test/java/fj/data/ArrayTest.java
index e274a00a..886031b3 100644
--- a/core/src/test/java/fj/data/ArrayTest.java
+++ b/core/src/test/java/fj/data/ArrayTest.java
@@ -3,6 +3,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertThat;
 
 /**
@@ -11,10 +12,10 @@
 public class ArrayTest {
 
     @Test
-    public void toJavaArray() {
-        final int max = 3;
-        List<Integer> list = List.range(1, max + 1);
-        assertThat(list.toArray().toJavaArray(), equalTo(list.toJavaArray()));
+    public void array_is_safe() {
+        List<Integer> list = List.range(1, 2);
+
+        assertThat(list.toArray().array(Integer[].class), instanceOf(Integer[].class));
     }
 
 }

From 14b7f5c0174ecd0ff99ec224dee73daeef381a74 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 09:37:58 +0100
Subject: [PATCH 025/336] Make non-extendable classes final.

---
 core/src/main/java/fj/Effect.java      | 2 +-
 core/src/main/java/fj/TryEffect.java   | 2 +-
 core/src/main/java/fj/data/DList.java  | 2 +-
 core/src/main/java/fj/data/IOW.java    | 2 +-
 core/src/main/java/fj/data/State.java  | 2 +-
 core/src/main/java/fj/data/Writer.java | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/core/src/main/java/fj/Effect.java b/core/src/main/java/fj/Effect.java
index aec3e442..387055f1 100644
--- a/core/src/main/java/fj/Effect.java
+++ b/core/src/main/java/fj/Effect.java
@@ -17,7 +17,7 @@
  *
  * @version %build.number%
  */
-public class Effect {
+public final class Effect {
 
 	private Effect() {}
 
diff --git a/core/src/main/java/fj/TryEffect.java b/core/src/main/java/fj/TryEffect.java
index 02d4521f..90acaf06 100644
--- a/core/src/main/java/fj/TryEffect.java
+++ b/core/src/main/java/fj/TryEffect.java
@@ -10,7 +10,7 @@
 /**
  * Created by mperry on 29/08/2014.
  */
-public class TryEffect {
+public final class TryEffect {
 
     private TryEffect(){}
 
diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index 2c7856de..3f7b2fe3 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -13,7 +13,7 @@
  *
  * @version %build.number%
  */
-public class DList<A> {
+public final class DList<A> {
     private final F<List<A>,Trampoline<List<A>>> appendFn;
     
     private DList(final F<List<A>,Trampoline<List<A>>> appendFn) {
diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index 4b146cde..b508456c 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -8,7 +8,7 @@
 /**
  * Created by MarkPerry on 9/06/2015.
  */
-public class IOW<A> implements IO<A> {
+public final class IOW<A> implements IO<A> {
 
     private IO<A> io;
 
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 46af5392..14620208 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -9,7 +9,7 @@
 /**
  * Created by MarkPerry on 7/07/2014.
  */
-public class State<S, A> {
+public final class State<S, A> {
 
 	private F<S, P2<S, A>> run;
 
diff --git a/core/src/main/java/fj/data/Writer.java b/core/src/main/java/fj/data/Writer.java
index 96e449e3..ad55c3ae 100644
--- a/core/src/main/java/fj/data/Writer.java
+++ b/core/src/main/java/fj/data/Writer.java
@@ -5,7 +5,7 @@
 /**
  * Created by MarkPerry on 7/07/2014.
  */
-public class Writer<W, A> {
+public final class Writer<W, A> {
 
 	private A val;
 	private W logValue;

From 9d2ca349043c673d468c76a4d8c8b3a0781cd12d Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 14:17:47 +0100
Subject: [PATCH 026/336] Fix some final modifiers. Add private constructor on
 utility classes.

---
 core/src/main/java/fj/Effect.java             |  4 +--
 core/src/main/java/fj/F1Functions.java        |  5 +++-
 core/src/main/java/fj/F2Functions.java        |  7 +++--
 core/src/main/java/fj/F3Functions.java        |  7 +++--
 core/src/main/java/fj/F4Functions.java        |  7 +++--
 core/src/main/java/fj/F5Functions.java        |  5 +++-
 core/src/main/java/fj/F6Functions.java        |  5 +++-
 core/src/main/java/fj/F7Functions.java        |  5 +++-
 core/src/main/java/fj/F8Functions.java        |  5 +++-
 core/src/main/java/fj/Ord.java                |  2 +-
 core/src/main/java/fj/Try.java                |  5 +++-
 .../main/java/fj/control/parallel/Actor.java  |  4 +--
 core/src/main/java/fj/data/IOFunctions.java   | 29 ++++++++++---------
 core/src/main/java/fj/data/Iteratee.java      | 16 +++++-----
 core/src/main/java/fj/data/Seq.java           |  4 +--
 .../main/java/fj/data/fingertrees/Deep.java   |  4 +--
 core/src/main/java/fj/data/optic/Fold.java    |  2 +-
 core/src/main/java/fj/data/optic/Getter.java  |  4 +--
 core/src/main/java/fj/data/optic/Iso.java     | 22 +++++++-------
 core/src/main/java/fj/data/optic/Lens.java    | 20 ++++++-------
 .../src/main/java/fj/data/optic/Optional.java | 22 +++++++-------
 core/src/main/java/fj/data/optic/PIso.java    |  2 +-
 core/src/main/java/fj/data/optic/PLens.java   |  2 +-
 .../main/java/fj/data/optic/POptional.java    |  2 +-
 core/src/main/java/fj/data/optic/PSetter.java |  4 +--
 core/src/main/java/fj/data/optic/Prism.java   | 18 ++++++------
 core/src/main/java/fj/data/optic/Setter.java  | 12 ++++----
 .../main/java/fj/data/optic/Traversal.java    |  8 ++---
 .../java/fj/data/test/PropertyAssert.java     |  4 ++-
 29 files changed, 134 insertions(+), 102 deletions(-)

diff --git a/core/src/main/java/fj/Effect.java b/core/src/main/java/fj/Effect.java
index 387055f1..6e5e7b7f 100644
--- a/core/src/main/java/fj/Effect.java
+++ b/core/src/main/java/fj/Effect.java
@@ -33,7 +33,7 @@ public static P1<Unit> f(Effect0 e) {
    *
    * @return The function using the given effect.
    */
-  public static final <A> F<A, Unit> f(Effect1<A> e1) {
+  public static <A> F<A, Unit> f(Effect1<A> e1) {
     return a -> {
         e1.f(a);
         return unit();
@@ -95,7 +95,7 @@ public static <A, B, C, D, E> F5<A, B, C, D, E, Unit> f(Effect5<A, B, C, D, E> z
    * @param f The function to map over the effect.
    * @return An effect after a contra-variant map.
    */
-  public static final <A, B> Effect1<B> contramap(Effect1<A> e1, final F<B, A> f) {
+  public static <A, B> Effect1<B> contramap(Effect1<A> e1, final F<B, A> f) {
     return b -> e1.f(f.f(b));
   }
   
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 2d3c56d4..640b624c 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -18,9 +18,12 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F1Functions {
+public final class F1Functions {
 
 
+    private F1Functions() {
+    }
+
     /**
      * Function composition
      *
diff --git a/core/src/main/java/fj/F2Functions.java b/core/src/main/java/fj/F2Functions.java
index c15a68cb..9ce1cc0a 100644
--- a/core/src/main/java/fj/F2Functions.java
+++ b/core/src/main/java/fj/F2Functions.java
@@ -13,10 +13,13 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F2Functions {
+public final class F2Functions {
 
 
-    /**
+  private F2Functions() {
+  }
+
+  /**
      * Partial application.
      *
      * @param a The <code>A</code> to which to apply this function.
diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
index 62d91aee..77a8fa74 100644
--- a/core/src/main/java/fj/F3Functions.java
+++ b/core/src/main/java/fj/F3Functions.java
@@ -9,10 +9,13 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F3Functions {
+public final class F3Functions {
 
 
-    /**
+  private F3Functions() {
+  }
+
+  /**
      * Partial application.
      *
      * @param a The <code>A</code> to which to apply this function.
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
index 71ee56a3..ab57247b 100644
--- a/core/src/main/java/fj/F4Functions.java
+++ b/core/src/main/java/fj/F4Functions.java
@@ -6,9 +6,12 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F4Functions {
+public final class F4Functions {
 
-    /**
+  private F4Functions() {
+  }
+
+  /**
      * Partial application.
      *
      * @param a The <code>A</code> to which to apply this function.
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
index 8cb26c6d..6345de01 100644
--- a/core/src/main/java/fj/F5Functions.java
+++ b/core/src/main/java/fj/F5Functions.java
@@ -6,7 +6,10 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F5Functions {
+public final class F5Functions {
+
+	private F5Functions() {
+	}
 
 	/**
 	 * Partial application.
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
index 70458593..19269e40 100644
--- a/core/src/main/java/fj/F6Functions.java
+++ b/core/src/main/java/fj/F6Functions.java
@@ -6,7 +6,10 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F6Functions {
+public final class F6Functions {
+
+	private F6Functions() {
+	}
 
 	/**
 	 * Partial application.
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
index a6ceff9f..4abcb986 100644
--- a/core/src/main/java/fj/F7Functions.java
+++ b/core/src/main/java/fj/F7Functions.java
@@ -6,7 +6,10 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F7Functions {
+public final class F7Functions {
+
+	private F7Functions() {
+	}
 
 	/**
 	 * Partial application.
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
index 788f106d..5cb9bb3b 100644
--- a/core/src/main/java/fj/F8Functions.java
+++ b/core/src/main/java/fj/F8Functions.java
@@ -6,7 +6,10 @@
 /**
  * Created by MarkPerry on 6/04/2014.
  */
-public class F8Functions {
+public final class F8Functions {
+
+	private F8Functions() {
+	}
 
 	/**
 	 * Partial application.
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index a7a39cac..780f5edf 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -157,7 +157,7 @@ public A min(final A a1, final A a2) {
    */
   public final F<A, F<A, A>> min = curry((a, a1) -> min(a, a1));
 
-  public final Ord<A> reverse() { return ord(Function.flip(f)); }
+  public Ord<A> reverse() { return ord(Function.flip(f)); }
 
   /**
    * Returns an order instance that uses the given equality test and ordering function.
diff --git a/core/src/main/java/fj/Try.java b/core/src/main/java/fj/Try.java
index 5ed2673f..c5829b01 100644
--- a/core/src/main/java/fj/Try.java
+++ b/core/src/main/java/fj/Try.java
@@ -13,7 +13,10 @@
 /**
  * Created by mperry on 24/07/2014.
  */
-public class Try {
+public final class Try {
+
+    private Try() {
+    }
 
     /**
      * Promotes the Try0 to a Validation that returns an Exception on the failure side and its result on the success side.
diff --git a/core/src/main/java/fj/control/parallel/Actor.java b/core/src/main/java/fj/control/parallel/Actor.java
index 77d4fe2d..301f057d 100644
--- a/core/src/main/java/fj/control/parallel/Actor.java
+++ b/core/src/main/java/fj/control/parallel/Actor.java
@@ -69,13 +69,13 @@ public static <T> Actor<T> queueActor(final Strategy<Unit> s, final Effect1<T> e
       }
 
       // If there are pending messages, use the strategy to run the processor
-      protected void work() {
+      void work() {
         if (!mbox.isEmpty() && suspended.compareAndSet(true, false)) {
           s.par(processor);
         }
       }
     });
-  };
+  }
   
   private Actor(final Strategy<Unit> s, final F<A, P1<Unit>> e) {
     this.s = s;
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index d53caf9a..1a3e93ff 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -26,10 +26,13 @@
  *
  * @author Martin Grotzke
  */
-public class IOFunctions {
+public final class IOFunctions {
 
     private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
 
+    private IOFunctions() {
+    }
+
     public static <A> Try0<A, IOException> toTry(IO<A> io) {
         return () -> io.run();
     }
@@ -133,7 +136,7 @@ public static IO<Reader> fileReader(final File f, final Option<Charset> encoding
         };
     }
 
-    public static final <A, B, C> IO<C> bracket(final IO<A> init, final F<A, IO<B>> fin, final F<A, IO<C>> body) {
+    public static <A, B, C> IO<C> bracket(final IO<A> init, final F<A, IO<B>> fin, final F<A, IO<C>> body) {
         return new IO<C>() {
             @Override
             public C run() throws IOException {
@@ -149,7 +152,7 @@ public C run() throws IOException {
         };
     }
 
-    public static final <A> IO<A> unit(final A a) {
+    public static <A> IO<A> unit(final A a) {
         return new IO<A>() {
             @Override
             public A run() throws IOException {
@@ -160,19 +163,19 @@ public A run() throws IOException {
 
     public static final IO<Unit> ioUnit = unit(Unit.unit());
 
-    public static final <A> IO<A> lazy(final F0<A> p) {
+    public static <A> IO<A> lazy(final F0<A> p) {
         return fromF(p);
     }
 
-    public static final <A> IO<A> lazy(final F<Unit, A> f) {
+    public static <A> IO<A> lazy(final F<Unit, A> f) {
         return () -> f.f(Unit.unit());
     }
 
-    public static final <A> SafeIO<A> lazySafe(final F<Unit, A> f) {
+    public static <A> SafeIO<A> lazySafe(final F<Unit, A> f) {
         return () -> f.f(Unit.unit());
     }
 
-    public static final <A> SafeIO<A> lazySafe(final F0<A> f) {
+    public static <A> SafeIO<A> lazySafe(final F0<A> f) {
         return f::f;
     }
 
@@ -330,7 +333,7 @@ public IterV<Character, A> run() throws IOException {
         };
     }
 
-    public static final <A, B> IO<B> map(final IO<A> io, final F<A, B> f) {
+    public static <A, B> IO<B> map(final IO<A> io, final F<A, B> f) {
         return new IO<B>() {
             @Override
             public B run() throws IOException {
@@ -339,15 +342,15 @@ public B run() throws IOException {
         };
     }
 
-    public static final <A, B> IO<B> as(final IO<A> io, final B b) {
+    public static <A, B> IO<B> as(final IO<A> io, final B b) {
         return map(io, ignored -> b);
     }
 
-    public static final <A> IO<Unit> voided(final IO <A> io) {
+    public static <A> IO<Unit> voided(final IO <A> io) {
         return as(io, Unit.unit());
     }
 
-    public static final <A, B> IO<B> bind(final IO<A> io, final F<A, IO<B>> f) {
+    public static <A, B> IO<B> bind(final IO<A> io, final F<A, IO<B>> f) {
         return new IO<B>() {
             @Override
             public B run() throws IOException {
@@ -356,11 +359,11 @@ public B run() throws IOException {
         };
     }
 
-    public static final IO<Unit> when(final Boolean b, final IO<Unit> io) {
+    public static IO<Unit> when(final Boolean b, final IO<Unit> io) {
         return b ? io : ioUnit;
     }
 
-    public static final IO<Unit> unless(final Boolean b, final IO<Unit> io) {
+    public static IO<Unit> unless(final Boolean b, final IO<Unit> io) {
         return when(!b, io);
     }
 
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index 9eaeb95e..e4cd3530 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -22,7 +22,7 @@ public static abstract class Input<E> {
     public abstract <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof);
 
     /** Input that has no values available */
-    public static final <E> Input<E> empty() {
+    public static <E> Input<E> empty() {
       return new Input<E>() {
         @Override
         public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
@@ -32,7 +32,7 @@ public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
     }
 
     /** Input that is exhausted */
-    public static final <E> Input<E> eof() {
+    public static <E> Input<E> eof() {
       return new Input<E>() {
         @Override
         public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
@@ -42,7 +42,7 @@ public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
     }
 
     /** Input that has a value available */
-    public static final <E> Input<E> el(final E element) {
+    public static <E> Input<E> el(final E element) {
       return new Input<E>() {
         @Override
         public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
@@ -121,7 +121,7 @@ public IterV<E, B> f(final P2<A, Input<E>> xe) {
     }
 
     /** An iteratee that counts and consumes the elements of the input */
-    public static final <E> IterV<E, Integer> length() {
+    public static <E> IterV<E, Integer> length() {
       final F<Integer, F<Input<E>, IterV<E, Integer>>> step =
         new F<Integer, F<Input<E>, IterV<E, Integer>>>() {
           final F<Integer, F<Input<E>, IterV<E, Integer>>> step = this;
@@ -141,7 +141,7 @@ public F<Input<E>, IterV<E, Integer>> f(final Integer acc) {
     }
 
     /** An iteratee that skips the first n elements of the input */
-    public static final <E> IterV<E, Unit> drop(final int n) {
+    public static <E> IterV<E, Unit> drop(final int n) {
       final F<Input<E>, IterV<E, Unit>> step =
         new F<Input<E>, IterV<E, Unit>>() {
           final F<Input<E>, IterV<E, Unit>> step = this;
@@ -163,7 +163,7 @@ public IterV<E, Unit> f(final Input<E> s) {
     }
 
     /** An iteratee that consumes the head of the input */
-    public static final <E> IterV<E, Option<E>> head() {
+    public static <E> IterV<E, Option<E>> head() {
       final F<Input<E>, IterV<E, Option<E>>> step =
         new F<Input<E>, IterV<E, Option<E>>>() {
           final F<Input<E>, IterV<E, Option<E>>> step = this;
@@ -183,7 +183,7 @@ public IterV<E, Option<E>> f(final Input<E> s) {
     }
 
     /** An iteratee that returns the first element of the input */
-    public static final <E> IterV<E, Option<E>> peek() {
+    public static <E> IterV<E, Option<E>> peek() {
       final F<Input<E>, IterV<E, Option<E>>> step =
         new F<Input<E>, IterV<E, Option<E>>>() {
           final F<Input<E>, IterV<E, Option<E>>> step = this;
@@ -204,7 +204,7 @@ public IterV<E, Option<E>> f(final Input<E> s) {
 
     /** An iteratee that consumes the input elements and returns them as a list in reverse order,
      * so that the last line is the first element. This allows to build a list from 2 iteratees. */
-    public static final <E> IterV<E, List<E>> list() {
+    public static <E> IterV<E, List<E>> list() {
         final F<List<E>, F<Input<E>, IterV<E, List<E>>>> step =
           new F<List<E>, F<Input<E>, IterV<E, List<E>>>>() {
             final F<List<E>, F<Input<E>, IterV<E, List<E>>>> step = this;
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index a29d97c0..00868ef3 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -214,7 +214,7 @@ public List<A> toList() {
   /**
    * Converts the sequence to a java.util.List
    */
-  public final java.util.List<A> toJavaList() {
+  public java.util.List<A> toJavaList() {
     return new AbstractList<A>() {
       @Override public A get(int i) { return index(i); }
       @Override public Iterator<A> iterator() { return Seq.this.iterator(); }
@@ -227,7 +227,7 @@ public final java.util.List<A> toJavaList() {
    *
    * @return A iterator for this seq.
    */
-  public final Iterator<A> iterator() {
+  public Iterator<A> iterator() {
     return new Iterator<A>() {
       private FingerTree<Integer, A> ftree = Seq.this.ftree;
 
diff --git a/core/src/main/java/fj/data/fingertrees/Deep.java b/core/src/main/java/fj/data/fingertrees/Deep.java
index e42bde4d..a33637d8 100644
--- a/core/src/main/java/fj/data/fingertrees/Deep.java
+++ b/core/src/main/java/fj/data/fingertrees/Deep.java
@@ -134,14 +134,14 @@ public FingerTree<V, A> snoc(final A a) {
       four -> four.values()._4());
   }
 
-  private static final <V, A> FingerTree<V, A> deepL(final Measured<V, A> measured, final Option<Digit<V, A>> lOpt, final FingerTree<V, Node<V, A>> m, final Digit<V, A> r) {
+  private static <V, A> FingerTree<V, A> deepL(final Measured<V, A> measured, final Option<Digit<V, A>> lOpt, final FingerTree<V, Node<V, A>> m, final Digit<V, A> r) {
     return lOpt.option(
       P.lazy(() -> m.isEmpty() ? r.toTree() : mkTree(measured).deep(m.head().toDigit(), m.tail(), r)),
       (F<Digit<V, A>, FingerTree<V, A>>) l -> mkTree(measured).deep(l, m, r)
     );
   }
 
-  private static final <V, A> FingerTree<V, A> deepR(final Measured<V, A> measured, final Option<Digit<V, A>> rOpt, final FingerTree<V, Node<V, A>> m, final Digit<V, A> l) {
+  private static <V, A> FingerTree<V, A> deepR(final Measured<V, A> measured, final Option<Digit<V, A>> rOpt, final FingerTree<V, Node<V, A>> m, final Digit<V, A> l) {
     return rOpt.option(
       P.lazy(() -> m.isEmpty() ? l.toTree() : mkTree(measured).deep(l, m.init(), m.last().toDigit())),
       (F<Digit<V, A>, FingerTree<V, A>>) r -> mkTree(measured).deep(l, m, r)
diff --git a/core/src/main/java/fj/data/optic/Fold.java b/core/src/main/java/fj/data/optic/Fold.java
index 94b8aaf6..21aca09f 100644
--- a/core/src/main/java/fj/data/optic/Fold.java
+++ b/core/src/main/java/fj/data/optic/Fold.java
@@ -110,7 +110,7 @@ public static <A> Fold<A, A> id() {
     return PIso.<A, A> pId().asFold();
   }
 
-  public static final <A> Fold<Either<A, A>, A> codiagonal() {
+  public static <A> Fold<Either<A, A>, A> codiagonal() {
     return new Fold<Either<A, A>, A>() {
       @Override
       public <B> F<Either<A, A>, B> foldMap(final Monoid<B> m, final F<A, B> f) {
diff --git a/core/src/main/java/fj/data/optic/Getter.java b/core/src/main/java/fj/data/optic/Getter.java
index b5c60d50..a5c9fa99 100644
--- a/core/src/main/java/fj/data/optic/Getter.java
+++ b/core/src/main/java/fj/data/optic/Getter.java
@@ -94,11 +94,11 @@ public static <A> Getter<A, A> id() {
     return PIso.<A, A> pId().asGetter();
   }
 
-  public static final <A> Getter<Either<A, A>, A> codiagonal() {
+  public static <A> Getter<Either<A, A>, A> codiagonal() {
     return getter(e -> e.either(Function.identity(), Function.identity()));
   }
 
-  public static final <S, A> Getter<S, A> getter(final F<S, A> get) {
+  public static <S, A> Getter<S, A> getter(final F<S, A> get) {
     return new Getter<S, A>() {
 
       @Override
diff --git a/core/src/main/java/fj/data/optic/Iso.java b/core/src/main/java/fj/data/optic/Iso.java
index 71ca7359..ea9babac 100644
--- a/core/src/main/java/fj/data/optic/Iso.java
+++ b/core/src/main/java/fj/data/optic/Iso.java
@@ -47,32 +47,32 @@ public <C> Iso<P2<C, S>, P2<C, A>> second() {
   /**********************************************************/
 
   /** compose an {@link Iso} with a {@link Setter} */
-  public final <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pIso.composeSetter(other.pSetter));
   }
 
   /** compose an {@link Iso} with a {@link Traversal} */
-  public final <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Traversal<>(pIso.composeTraversal(other.pTraversal));
   }
 
   /** compose an {@link Iso} with a {@link Optional} */
-  public final <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
+  public <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
     return new Optional<>(pIso.composeOptional(other.pOptional));
   }
 
   /** compose an {@link Iso} with a {@link Prism} */
-  public final <C> Prism<S, C> composePrism(final Prism<A, C> other) {
+  public <C> Prism<S, C> composePrism(final Prism<A, C> other) {
     return new Prism<>(pIso.composePrism(other.pPrism));
   }
 
   /** compose an {@link Iso} with a {@link Lens} */
-  public final <C> Lens<S, C> composeLens(final Lens<A, C> other) {
+  public <C> Lens<S, C> composeLens(final Lens<A, C> other) {
     return asLens().composeLens(other);
   }
 
   /** compose an {@link Iso} with an {@link Iso} */
-  public final <C> Iso<S, C> composeIso(final Iso<A, C> other) {
+  public <C> Iso<S, C> composeIso(final Iso<A, C> other) {
     return new Iso<>(pIso.composeIso(other.pIso));
   }
 
@@ -82,31 +82,31 @@ public final <C> Iso<S, C> composeIso(final Iso<A, C> other) {
 
   /** view an {@link Iso} as a {@link Setter} */
   @Override
-  public final Setter<S, A> asSetter() {
+  public Setter<S, A> asSetter() {
     return new Setter<>(pIso.asSetter());
   }
 
   /** view an {@link Iso} as a {@link Traversal} */
   @Override
-  public final Traversal<S, A> asTraversal() {
+  public Traversal<S, A> asTraversal() {
     return new Traversal<>(pIso.asTraversal());
   }
 
   /** view an {@link Iso} as a {@link Optional} */
   @Override
-  public final Optional<S, A> asOptional() {
+  public Optional<S, A> asOptional() {
     return new Optional<>(pIso.asOptional());
   }
 
   /** view an {@link Iso} as a {@link Prism} */
   @Override
-  public final Prism<S, A> asPrism() {
+  public Prism<S, A> asPrism() {
     return new Prism<>(pIso.asPrism());
   }
 
   /** view an {@link Iso} as a {@link Lens} */
   @Override
-  public final Lens<S, A> asLens() {
+  public Lens<S, A> asLens() {
     return new Lens<>(pIso.asLens());
   }
 
diff --git a/core/src/main/java/fj/data/optic/Lens.java b/core/src/main/java/fj/data/optic/Lens.java
index bb65952b..ceea42c9 100644
--- a/core/src/main/java/fj/data/optic/Lens.java
+++ b/core/src/main/java/fj/data/optic/Lens.java
@@ -94,7 +94,7 @@ public F<S, S> modify(final F<A, A> f) {
   }
 
   /** join two {@link Lens} with the same target */
-  public final <S1> Lens<Either<S, S1>, A> sum(final Lens<S1, A> other) {
+  public <S1> Lens<Either<S, S1>, A> sum(final Lens<S1, A> other) {
     return new Lens<>(pLens.sum(other.pLens));
   }
 
@@ -105,34 +105,34 @@ public final <S1> Lens<Either<S, S1>, A> sum(final Lens<S1, A> other) {
   /**
    * compose a {@link Lens} with a {@link Setter}
    */
-  public final <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pLens.composeSetter(other.pSetter));
   }
 
   /**
    * compose a {@link Lens} with a {@link Traversal}
    */
-  public final <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Traversal<>(pLens.composeTraversal(other.pTraversal));
   }
 
   /** compose a {@link Lens} with an {@link Optional} */
-  public final <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
+  public <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
     return new Optional<>(pLens.composeOptional(other.pOptional));
   }
 
   /** compose a {@link Lens} with a {@link Prism} */
-  public final <C> Optional<S, C> composePrism(final Prism<A, C> other) {
+  public <C> Optional<S, C> composePrism(final Prism<A, C> other) {
     return new Optional<>(pLens.composePrism(other.pPrism));
   }
 
   /** compose a {@link Lens} with a {@link Lens} */
-  public final <C> Lens<S, C> composeLens(final Lens<A, C> other) {
+  public <C> Lens<S, C> composeLens(final Lens<A, C> other) {
     return new Lens<>(pLens.composeLens(other.pLens));
   }
 
   /** compose a {@link Lens} with an {@link Iso} */
-  public final <C> Lens<S, C> composeIso(final Iso<A, C> other) {
+  public <C> Lens<S, C> composeIso(final Iso<A, C> other) {
     return new Lens<>(pLens.composeIso(other.pIso));
   }
 
@@ -148,17 +148,17 @@ public Setter<S, A> asSetter() {
 
   /** view a {@link Lens} as a {@link Traversal} */
   @Override
-  public final Traversal<S, A> asTraversal() {
+  public Traversal<S, A> asTraversal() {
     return new Traversal<>(pLens.asTraversal());
   }
 
   /** view a {@link Lens} as an {@link Optional} */
   @Override
-  public final Optional<S, A> asOptional() {
+  public Optional<S, A> asOptional() {
     return new Optional<>(pLens.asOptional());
   }
 
-  public static final <S> Lens<S, S> id() {
+  public static <S> Lens<S, S> id() {
     return new Lens<>(PLens.pId());
   }
 
diff --git a/core/src/main/java/fj/data/optic/Optional.java b/core/src/main/java/fj/data/optic/Optional.java
index ed737cf0..200a952d 100644
--- a/core/src/main/java/fj/data/optic/Optional.java
+++ b/core/src/main/java/fj/data/optic/Optional.java
@@ -103,17 +103,17 @@ public Option<A> getOption(final S s) {
   }
 
   /** join two {@link Optional} with the same target */
-  public final <S1> Optional<Either<S, S1>, A> sum(final Optional<S1, A> other) {
+  public <S1> Optional<Either<S, S1>, A> sum(final Optional<S1, A> other) {
     return new Optional<>(pOptional.sum(other.pOptional));
   }
 
   @Override
-  public final <C> Optional<P2<S, C>, P2<A, C>> first() {
+  public <C> Optional<P2<S, C>, P2<A, C>> first() {
     return new Optional<>(pOptional.first());
   }
 
   @Override
-  public final <C> Optional<P2<C, S>, P2<C, A>> second() {
+  public <C> Optional<P2<C, S>, P2<C, A>> second() {
     return new Optional<>(pOptional.second());
   }
 
@@ -122,32 +122,32 @@ public final <C> Optional<P2<C, S>, P2<C, A>> second() {
   /**************************************************************/
 
   /** compose a {@link Optional} with a {@link Setter} */
-  public final <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pOptional.composeSetter(other.pSetter));
   }
 
   /** compose a {@link Optional} with a {@link Traversal} */
-  public final <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Traversal<>(pOptional.composeTraversal(other.pTraversal));
   }
 
   /** compose a {@link Optional} with a {@link Optional} */
-  public final <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
+  public <C> Optional<S, C> composeOptional(final Optional<A, C> other) {
     return new Optional<>(pOptional.composeOptional(other.pOptional));
   }
 
   /** compose a {@link Optional} with a {@link Prism} */
-  public final <C> Optional<S, C> composePrism(final Prism<A, C> other) {
+  public <C> Optional<S, C> composePrism(final Prism<A, C> other) {
     return new Optional<>(pOptional.composePrism(other.pPrism));
   }
 
   /** compose a {@link Optional} with a {@link Lens} */
-  public final <C> Optional<S, C> composeLens(final Lens<A, C> other) {
+  public <C> Optional<S, C> composeLens(final Lens<A, C> other) {
     return new Optional<>(pOptional.composeLens(other.pLens));
   }
 
   /** compose a {@link Optional} with an {@link Iso} */
-  public final <C> Optional<S, C> composeIso(final Iso<A, C> other) {
+  public <C> Optional<S, C> composeIso(final Iso<A, C> other) {
     return new Optional<>(pOptional.composeIso(other.pIso));
   }
 
@@ -157,13 +157,13 @@ public final <C> Optional<S, C> composeIso(final Iso<A, C> other) {
 
   /** view a {@link Optional} as a {@link Setter} */
   @Override
-  public final Setter<S, A> asSetter() {
+  public Setter<S, A> asSetter() {
     return new Setter<>(pOptional.asSetter());
   }
 
   /** view a {@link Optional} as a {@link Traversal} */
   @Override
-  public final Traversal<S, A> asTraversal() {
+  public Traversal<S, A> asTraversal() {
     return new Traversal<>(pOptional.asTraversal());
   }
 
diff --git a/core/src/main/java/fj/data/optic/PIso.java b/core/src/main/java/fj/data/optic/PIso.java
index 850dedb6..4ed45ca0 100644
--- a/core/src/main/java/fj/data/optic/PIso.java
+++ b/core/src/main/java/fj/data/optic/PIso.java
@@ -510,7 +510,7 @@ public F<S, V2<T>> modifyV2F(final F<A, V2<B>> f) {
   }
 
   /** create a {@link PIso} using a pair of functions: one to get the target and one to get the source. */
-  public static final <S, T, A, B> PIso<S, T, A, B> pIso(final F<S, A> get, final F<B, T> reverseGet) {
+  public static <S, T, A, B> PIso<S, T, A, B> pIso(final F<S, A> get, final F<B, T> reverseGet) {
     return new PIso<S, T, A, B>() {
 
       @Override
diff --git a/core/src/main/java/fj/data/optic/PLens.java b/core/src/main/java/fj/data/optic/PLens.java
index ade9b9e7..68de9079 100644
--- a/core/src/main/java/fj/data/optic/PLens.java
+++ b/core/src/main/java/fj/data/optic/PLens.java
@@ -418,7 +418,7 @@ public F<S, T> modify(final F<A, B> f) {
     };
   }
 
-  public static final <S, T> PLens<S, T, S, T> pId() {
+  public static <S, T> PLens<S, T, S, T> pId() {
     return PIso.<S, T> pId().asLens();
   }
 
diff --git a/core/src/main/java/fj/data/optic/POptional.java b/core/src/main/java/fj/data/optic/POptional.java
index b1b0fa6e..92e4edf0 100644
--- a/core/src/main/java/fj/data/optic/POptional.java
+++ b/core/src/main/java/fj/data/optic/POptional.java
@@ -366,7 +366,7 @@ public static <S, T> POptional<S, T, S, T> pId() {
   }
 
   /** create a {@link POptional} using the canonical functions: getOrModify and set */
-  public static final <S, T, A, B> POptional<S, T, A, B> pOptional(final F<S, Either<T, A>> getOrModify, final F<B, F<S, T>> set) {
+  public static <S, T, A, B> POptional<S, T, A, B> pOptional(final F<S, Either<T, A>> getOrModify, final F<B, F<S, T>> set) {
     return new POptional<S, T, A, B>() {
       @Override
       public Either<T, A> getOrModify(final S s) {
diff --git a/core/src/main/java/fj/data/optic/PSetter.java b/core/src/main/java/fj/data/optic/PSetter.java
index ad8e3ea8..012920cb 100644
--- a/core/src/main/java/fj/data/optic/PSetter.java
+++ b/core/src/main/java/fj/data/optic/PSetter.java
@@ -84,11 +84,11 @@ public static <S, T> PSetter<S, T, S, T> pId() {
     return PIso.<S, T> pId().asSetter();
   }
 
-  public static final <S, T> PSetter<Either<S, S>, Either<T, T>, S, T> pCodiagonal() {
+  public static <S, T> PSetter<Either<S, S>, Either<T, T>, S, T> pCodiagonal() {
     return pSetter(f -> e -> e.bimap(f, f));
   }
 
-  public static final <S, T, A, B> PSetter<S, T, A, B> pSetter(final F<F<A, B>, F<S, T>> modify) {
+  public static <S, T, A, B> PSetter<S, T, A, B> pSetter(final F<F<A, B>, F<S, T>> modify) {
     return new PSetter<S, T, A, B>() {
       @Override
       public F<S, T> modify(final F<A, B> f) {
diff --git a/core/src/main/java/fj/data/optic/Prism.java b/core/src/main/java/fj/data/optic/Prism.java
index 409bfc6d..42decaaf 100644
--- a/core/src/main/java/fj/data/optic/Prism.java
+++ b/core/src/main/java/fj/data/optic/Prism.java
@@ -35,32 +35,32 @@ public Option<A> getOption(final S s) {
   /***********************************************************/
 
   /** compose a {@link Prism} with a {@link Setter} */
-  public final <C, D> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C, D> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pPrism.composeSetter(other.pSetter));
   }
 
   /** compose a {@link Prism} with a {@link Traversal} */
-  public final <C, D> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C, D> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Traversal<>(pPrism.composeTraversal(other.pTraversal));
   }
 
   /** compose a {@link Prism} with a {@link Optional} */
-  public final <C, D> Optional<S, C> composeOptional(final Optional<A, C> other) {
+  public <C, D> Optional<S, C> composeOptional(final Optional<A, C> other) {
     return new Optional<>(pPrism.composeOptional(other.pOptional));
   }
 
   /** compose a {@link Prism} with a {@link Lens} */
-  public final <C, D> Optional<S, C> composeLens(final Lens<A, C> other) {
+  public <C, D> Optional<S, C> composeLens(final Lens<A, C> other) {
     return new Optional<>(pPrism.composeLens(other.pLens));
   }
 
   /** compose a {@link Prism} with a {@link Prism} */
-  public final <C> Prism<S, C> composePrism(final Prism<A, C> other) {
+  public <C> Prism<S, C> composePrism(final Prism<A, C> other) {
     return new Prism<>(pPrism.composePrism(other.pPrism));
   }
 
   /** compose a {@link Prism} with an {@link Iso} */
-  public final <C, D> Prism<S, C> composeIso(final Iso<A, C> other) {
+  public <C, D> Prism<S, C> composeIso(final Iso<A, C> other) {
     return new Prism<>(pPrism.composeIso(other.pIso));
   }
 
@@ -70,19 +70,19 @@ public final <C, D> Prism<S, C> composeIso(final Iso<A, C> other) {
 
   /** view a {@link Prism} as a {@link Setter} */
   @Override
-  public final Setter<S, A> asSetter() {
+  public Setter<S, A> asSetter() {
     return new Setter<>(pPrism.asSetter());
   }
 
   /** view a {@link Prism} as a {@link Traversal} */
   @Override
-  public final Traversal<S, A> asTraversal() {
+  public Traversal<S, A> asTraversal() {
     return new Traversal<>(pPrism.asTraversal());
   }
 
   /** view a {@link Prism} as a {@link Optional} */
   @Override
-  public final Optional<S, A> asOptional() {
+  public Optional<S, A> asOptional() {
     return new Optional<>(pPrism.asOptional());
   }
 
diff --git a/core/src/main/java/fj/data/optic/Setter.java b/core/src/main/java/fj/data/optic/Setter.java
index 40fc8473..95227f10 100644
--- a/core/src/main/java/fj/data/optic/Setter.java
+++ b/core/src/main/java/fj/data/optic/Setter.java
@@ -23,7 +23,7 @@ public F<S, S> set(final A b) {
   }
 
   /** join two {@link Setter} with the same target */
-  public final <S1> Setter<Either<S, S1>, A> sum(final Setter<S1, A> other) {
+  public <S1> Setter<Either<S, S1>, A> sum(final Setter<S1, A> other) {
     return new Setter<>(pSetter.sum(other.pSetter));
   }
 
@@ -32,17 +32,17 @@ public final <S1> Setter<Either<S, S1>, A> sum(final Setter<S1, A> other) {
   /************************************************************/
 
   /** compose a {@link Setter} with a {@link Setter} */
-  public final <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pSetter.composeSetter(other.pSetter));
   }
 
   /** compose a {@link Setter} with a {@link Traversal} */
-  public final <C> Setter<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C> Setter<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Setter<>(pSetter.composeTraversal(other.pTraversal));
   }
 
   /** compose a {@link Setter} with an {@link Iso} */
-  public final <C> Setter<S, C> composeIso(final Iso<A, C> other) {
+  public <C> Setter<S, C> composeIso(final Iso<A, C> other) {
     return new Setter<>(pSetter.composeIso(other.pIso));
   }
 
@@ -50,12 +50,12 @@ public static <S> Setter<S, S> id() {
     return new Setter<>(PSetter.pId());
   }
 
-  public static final <S> Setter<Either<S, S>, S> codiagonal() {
+  public static <S> Setter<Either<S, S>, S> codiagonal() {
     return new Setter<>(PSetter.pCodiagonal());
   }
 
   /** alias for {@link PSetter} constructor with a monomorphic modify function */
-  public static final <S, A> Setter<S, A> setter(final F<F<A, A>, F<S, S>> modify) {
+  public static <S, A> Setter<S, A> setter(final F<F<A, A>, F<S, S>> modify) {
     return new Setter<>(PSetter.pSetter(modify));
   }
 }
diff --git a/core/src/main/java/fj/data/optic/Traversal.java b/core/src/main/java/fj/data/optic/Traversal.java
index 756a95ed..4064385e 100644
--- a/core/src/main/java/fj/data/optic/Traversal.java
+++ b/core/src/main/java/fj/data/optic/Traversal.java
@@ -87,7 +87,7 @@ public <M> F<S, M> foldMap(final Monoid<M> monoid, final F<A, M> f) {
   }
 
   /** join two {@link Traversal} with the same target */
-  public final <S1> Traversal<Either<S, S1>, A> sum(final Traversal<S1, A> other) {
+  public <S1> Traversal<Either<S, S1>, A> sum(final Traversal<S1, A> other) {
     return new Traversal<>(pTraversal.sum(other.pTraversal));
   }
 
@@ -96,12 +96,12 @@ public final <S1> Traversal<Either<S, S1>, A> sum(final Traversal<S1, A> other)
   /***************************************************************/
 
   /** compose a {@link Traversal} with a {@link Setter} */
-  public final <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
+  public <C> Setter<S, C> composeSetter(final Setter<A, C> other) {
     return new Setter<>(pTraversal.composeSetter(other.pSetter));
   }
 
   /** compose a {@link Traversal} with a {@link Traversal} */
-  public final <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
+  public <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
     return new Traversal<>(pTraversal.composeTraversal(other.pTraversal));
   }
 
@@ -111,7 +111,7 @@ public final <C> Traversal<S, C> composeTraversal(final Traversal<A, C> other) {
 
   /** view a {@link Traversal} as a {@link Setter} */
   @Override
-  public final Setter<S, A> asSetter() {
+  public Setter<S, A> asSetter() {
     return new Setter<>(pTraversal.asSetter());
   }
 
diff --git a/quickcheck/src/main/java/fj/data/test/PropertyAssert.java b/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
index bec07f7f..00187b15 100644
--- a/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
+++ b/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
@@ -8,7 +8,9 @@
 /**
  * Created by MarkPerry on 18/12/2014.
  */
-public class PropertyAssert {
+public final class PropertyAssert {
+
+    private PropertyAssert(){}
 
     public static Unit assertResult(Property p) {
         CheckResult cr = p.check();

From 9eaabfafa0588142555d5976e11b57d43cf3d0c2 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 17:07:19 +0100
Subject: [PATCH 027/336] Make instance fields final when possible

---
 core/src/main/java/fj/control/parallel/Actor.java | 6 +++---
 core/src/main/java/fj/data/IOW.java               | 2 +-
 core/src/main/java/fj/data/Reader.java            | 2 +-
 core/src/main/java/fj/data/State.java             | 2 +-
 core/src/main/java/fj/data/Writer.java            | 6 +++---
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/core/src/main/java/fj/control/parallel/Actor.java b/core/src/main/java/fj/control/parallel/Actor.java
index 301f057d..bd1956bd 100644
--- a/core/src/main/java/fj/control/parallel/Actor.java
+++ b/core/src/main/java/fj/control/parallel/Actor.java
@@ -36,14 +36,14 @@ public static <T> Actor<T> queueActor(final Strategy<Unit> s, final Effect1<T> e
     return actor(Strategy.<Unit>seqStrategy(), new Effect1<T>() {
 
       // Lock to ensure the actor only acts on one message at a time
-      AtomicBoolean suspended = new AtomicBoolean(true);
+      final AtomicBoolean suspended = new AtomicBoolean(true);
 
       // Queue to hold pending messages
-      ConcurrentLinkedQueue<T> mbox = new ConcurrentLinkedQueue<T>();
+      final ConcurrentLinkedQueue<T> mbox = new ConcurrentLinkedQueue<T>();
 
       // Product so the actor can use its strategy (to act on messages in other threads,
       // to handle exceptions, etc.)
-      P1<Unit> processor = new P1<Unit>() {
+      final P1<Unit> processor = new P1<Unit>() {
         @Override public Unit _1() {
           // get next item from queue
           T a = mbox.poll();
diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index b508456c..8b1b2ac6 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -10,7 +10,7 @@
  */
 public final class IOW<A> implements IO<A> {
 
-    private IO<A> io;
+    private final IO<A> io;
 
     private IOW(IO<A> in) {
         io = in;
diff --git a/core/src/main/java/fj/data/Reader.java b/core/src/main/java/fj/data/Reader.java
index 34a98c72..749f4c9b 100644
--- a/core/src/main/java/fj/data/Reader.java
+++ b/core/src/main/java/fj/data/Reader.java
@@ -9,7 +9,7 @@
  */
 public class Reader<A, B> {
 
-	private F<A, B> function;
+	private final F<A, B> function;
 
 	public Reader(F<A, B> f) {
 		function = f;
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 14620208..c54d6cb7 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -11,7 +11,7 @@
  */
 public final class State<S, A> {
 
-	private F<S, P2<S, A>> run;
+	private final F<S, P2<S, A>> run;
 
 	private State(F<S, P2<S, A>> f) {
 		run = f;
diff --git a/core/src/main/java/fj/data/Writer.java b/core/src/main/java/fj/data/Writer.java
index ad55c3ae..7ff57d07 100644
--- a/core/src/main/java/fj/data/Writer.java
+++ b/core/src/main/java/fj/data/Writer.java
@@ -7,9 +7,9 @@
  */
 public final class Writer<W, A> {
 
-	private A val;
-	private W logValue;
-    private Monoid<W> monoid;
+	private final A val;
+	private final W logValue;
+	private final Monoid<W> monoid;
 
 	private Writer(A a, W w, Monoid<W> m) {
 		val = a;

From 2b8c1af39c515beb79fd63e34cb66cbfe9913b7a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 17:08:38 +0100
Subject: [PATCH 028/336] Correct order of modifiers according to JLS

---
 core/src/main/java/fj/F1Functions.java        | 136 +++++++++---------
 core/src/main/java/fj/F2Functions.java        |  52 +++----
 core/src/main/java/fj/F3Functions.java        |   2 +-
 core/src/main/java/fj/F4Functions.java        |   2 +-
 core/src/main/java/fj/F5Functions.java        |   2 +-
 core/src/main/java/fj/F6Functions.java        |   2 +-
 core/src/main/java/fj/F7Functions.java        |   2 +-
 core/src/main/java/fj/F8Functions.java        |   2 +-
 core/src/main/java/fj/Try.java                |  16 +--
 core/src/main/java/fj/control/Trampoline.java |   2 +-
 core/src/main/java/fj/data/Conversions.java   |   2 +-
 core/src/main/java/fj/data/Iteratee.java      |   4 +-
 java8/src/main/java/fj/data/Java8.java        |  36 ++---
 13 files changed, 130 insertions(+), 130 deletions(-)

diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 640b624c..5821a893 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -30,7 +30,7 @@ private F1Functions() {
      * @param g A function to compose with this one.
      * @return The composed function such that this function is applied last.
      */
-    static public <A, B, C> F<C, B> o(final F<A, B> f, final F<C, A> g) {
+    public static <A, B, C> F<C, B> o(final F<A, B> f, final F<C, A> g) {
         return c -> f.f(g.f(c));
     }
 
@@ -39,7 +39,7 @@ static public <A, B, C> F<C, B> o(final F<A, B> f, final F<C, A> g) {
      *
      * @return A function that composes this function with another.
      */
-    static public <A, B,C> F<F<C, A>, F<C, B>> o(final F<A, B> f) {
+    public static <A, B,C> F<F<C, A>, F<C, B>> o(final F<A, B> f) {
         return g -> o(f, g);
     }
 
@@ -50,7 +50,7 @@ static public <A, B,C> F<F<C, A>, F<C, B>> o(final F<A, B> f) {
      * @return The composed function such that this function is applied first.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B, C> F<A, C> andThen(final F<A, B> f, final F<B, C> g) {
+    public static <A, B, C> F<A, C> andThen(final F<A, B> f, final F<B, C> g) {
         return o(g, f);
     }
 
@@ -59,7 +59,7 @@ static public <A, B, C> F<A, C> andThen(final F<A, B> f, final F<B, C> g) {
      *
      * @return A function that invokes this function and then a given function on the result.
      */
-    static public <A, B, C> F<F<B, C>, F<A, C>> andThen(final F<A, B> f) {
+    public static <A, B, C> F<F<B, C>, F<A, C>> andThen(final F<A, B> f) {
         return g -> andThen(f, g);
     }
 
@@ -69,7 +69,7 @@ static public <A, B, C> F<F<B, C>, F<A, C>> andThen(final F<A, B> f) {
      * @param g A function that takes the return value of this function as an argument, yielding a new function.
      * @return A function that invokes this function on its argument and then the given function on the result.
      */
-    static public <A, B, C> F<A, C> bind(final F<A, B> f, final F<B, F<A, C>> g) {
+    public static <A, B, C> F<A, C> bind(final F<A, B> f, final F<B, F<A, C>> g) {
         return a ->  g.f(f.f(a)).f(a);
     }
 
@@ -78,7 +78,7 @@ static public <A, B, C> F<A, C> bind(final F<A, B> f, final F<B, F<A, C>> g) {
      *
      * @return A function that binds another function across this function.
      */
-    static public <A, B, C> F<F<B, F<A, C>>, F<A, C>> bind(final F<A, B> f) {
+    public static <A, B, C> F<F<B, F<A, C>>, F<A, C>> bind(final F<A, B> f) {
         return g -> bind(f, g);
     }
 
@@ -90,7 +90,7 @@ static public <A, B, C> F<F<B, F<A, C>>, F<A, C>> bind(final F<A, B> f) {
      * @return A new function that invokes the given function on its argument, yielding a new function that is then
      *         applied to the result of applying this function to the argument.
      */
-    static public <A, B, C> F<A, C> apply(final F<A, B> f, final F<A, F<B, C>> g) {
+    public static <A, B, C> F<A, C> apply(final F<A, B> f, final F<A, F<B, C>> g) {
         return a -> g.f(a).f(f.f(a));
     }
 
@@ -99,7 +99,7 @@ static public <A, B, C> F<A, C> apply(final F<A, B> f, final F<A, F<B, C>> g) {
      *
      * @return A function that applies a given function within the environment of this function.
      */
-    static public <A, B, C> F<F<A, F<B, C>>, F<A, C>> apply(final F<A, B> f) {
+    public static <A, B, C> F<F<A, F<B, C>>, F<A, C>> apply(final F<A, B> f) {
         return g -> apply(f, g);
     }
 
@@ -109,7 +109,7 @@ static public <A, B, C> F<F<A, F<B, C>>, F<A, C>> apply(final F<A, B> f) {
      * @param g The function over whose arguments to apply this function.
      * @return A new function that invokes this function on its arguments before invoking the given function.
      */
-    static public <A, B, C> F<A, F<A, C>> on(final F<A, B> f, final F<B, F<B, C>> g) {
+    public static <A, B, C> F<A, F<A, C>> on(final F<A, B> f, final F<B, F<B, C>> g) {
         return a1 -> a2 -> g.f(f.f(a1)).f(f.f(a2));
     }
 
@@ -120,7 +120,7 @@ static public <A, B, C> F<A, F<A, C>> on(final F<A, B> f, final F<B, F<B, C>> g)
      *
      * @return A function that applies this function over the arguments of another function.
      */
-    static public <A, B, C> F<F<B, F<B, C>>, F<A, F<A, C>>> on(final F<A, B> f) {
+    public static <A, B, C> F<F<B, F<B, C>>, F<A, F<A, C>>> on(final F<A, B> f) {
         return g -> on(f, g);
     }
 
@@ -129,7 +129,7 @@ static public <A, B, C> F<F<B, F<B, C>>, F<A, F<A, C>>> on(final F<A, B> f) {
      *
      * @return This function promoted to return its result in a product-1.
      */
-    static public <A, B> F<A, P1<B>> lazy(final F<A, B> f) {
+    public static <A, B> F<A, P1<B>> lazy(final F<A, B> f) {
        return a -> P.lazy(() -> f.f(a));
     }
 
@@ -139,7 +139,7 @@ static public <A, B> F<A, P1<B>> lazy(final F<A, B> f) {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument to return a lazy value.
      */
-    static public <A, B> P1<B> f(final F<A, B> f, final A a) {
+    public static <A, B> P1<B> f(final F<A, B> f, final A a) {
         return P.lazy(() -> f.f(a));
     }
 
@@ -148,7 +148,7 @@ static public <A, B> P1<B> f(final F<A, B> f, final A a) {
      *
      * @return This function promoted to map over a product-1.
      */
-    static public <A, B> F<P1<A>, P1<B>> mapP1(final F<A, B> f) {
+    public static <A, B> F<P1<A>, P1<B>> mapP1(final F<A, B> f) {
         return p -> p.map(f);
     }
 
@@ -157,7 +157,7 @@ static public <A, B> F<P1<A>, P1<B>> mapP1(final F<A, B> f) {
      *
      * @return This function promoted to return its result in an Option.
      */
-    static public <A, B> F<A, Option<B>> optionK(final F<A, B> f) {
+    public static <A, B> F<A, Option<B>> optionK(final F<A, B> f) {
         return a -> some(f.f(a));
     }
 
@@ -166,7 +166,7 @@ static public <A, B> F<A, Option<B>> optionK(final F<A, B> f) {
      *
      * @return This function promoted to map over an optional value.
      */
-    static public <A, B> F<Option<A>, Option<B>> mapOption(final F<A, B> f) {
+    public static <A, B> F<Option<A>, Option<B>> mapOption(final F<A, B> f) {
         return o -> o.map(f);
     }
 
@@ -175,7 +175,7 @@ static public <A, B> F<Option<A>, Option<B>> mapOption(final F<A, B> f) {
      *
      * @return This function promoted to return its result in a List.
      */
-    static public <A, B> F<A, List<B>> listK(final F<A, B> f) {
+    public static <A, B> F<A, List<B>> listK(final F<A, B> f) {
         return a -> List.single(f.f(a));
     }
 
@@ -184,7 +184,7 @@ static public <A, B> F<A, List<B>> listK(final F<A, B> f) {
      *
      * @return This function promoted to map over a List.
      */
-    static public <A, B> F<List<A>, List<B>> mapList(final F<A, B> f) {
+    public static <A, B> F<List<A>, List<B>> mapList(final F<A, B> f) {
         return x -> x.map(f);
     }
 
@@ -193,7 +193,7 @@ static public <A, B> F<List<A>, List<B>> mapList(final F<A, B> f) {
      *
      * @return This function promoted to return its result in a Stream.
      */
-    static public <A, B> F<A, Stream<B>> streamK(final F<A, B> f) {
+    public static <A, B> F<A, Stream<B>> streamK(final F<A, B> f) {
         return a -> Stream.single(f.f(a));
     }
 
@@ -202,7 +202,7 @@ static public <A, B> F<A, Stream<B>> streamK(final F<A, B> f) {
      *
      * @return This function promoted to map over a Stream.
      */
-    static public <A, B> F<Stream<A>, Stream<B>> mapStream(final F<A, B> f) {
+    public static <A, B> F<Stream<A>, Stream<B>> mapStream(final F<A, B> f) {
         return x -> x.map(f);
     }
 
@@ -211,7 +211,7 @@ static public <A, B> F<Stream<A>, Stream<B>> mapStream(final F<A, B> f) {
      *
      * @return This function promoted to return its result in a Array.
      */
-    static public <A, B> F<A, Array<B>> arrayK(final F<A, B> f) {
+    public static <A, B> F<A, Array<B>> arrayK(final F<A, B> f) {
         return a -> Array.single(f.f(a));
 
     }
@@ -221,7 +221,7 @@ static public <A, B> F<A, Array<B>> arrayK(final F<A, B> f) {
      *
      * @return This function promoted to map over a Array.
      */
-    static public <A, B> F<Array<A>, Array<B>> mapArray(final F<A, B> f) {
+    public static <A, B> F<Array<A>, Array<B>> mapArray(final F<A, B> f) {
         return x -> x.map(f);
     }
 
@@ -230,7 +230,7 @@ static public <A, B> F<Array<A>, Array<B>> mapArray(final F<A, B> f) {
      *
      * @return A function that contramaps over a given actor.
      */
-    static public <A, B> F<Actor<B>, Actor<A>> contramapActor(final F<A, B> f) {
+    public static <A, B> F<Actor<B>, Actor<A>> contramapActor(final F<A, B> f) {
         return a -> a.contramap(f);
     }
 
@@ -240,7 +240,7 @@ static public <A, B> F<Actor<B>, Actor<A>> contramapActor(final F<A, B> f) {
      * @param s A parallel strategy for concurrent execution.
      * @return A concurrent function that returns a Promise of a value.
      */
-    static public <A, B> F<A, Promise<B>> promiseK(final F<A, B> f, final Strategy<Unit> s) {
+    public static <A, B> F<A, Promise<B>> promiseK(final F<A, B> f, final Strategy<Unit> s) {
         return Promise.promise(s, f);
     }
 
@@ -249,7 +249,7 @@ static public <A, B> F<A, Promise<B>> promiseK(final F<A, B> f, final Strategy<U
      *
      * @return This function promoted to map over Promises.
      */
-    static public <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
+    public static <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
         return p -> p.fmap(f);
     }
 
@@ -260,7 +260,7 @@ static public <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
      * @return This function promoted to return its result on the left side of an Either.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
+    public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
         return o(Either.<B, C>left_(), f);
     }
 
@@ -271,7 +271,7 @@ static public <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
      * @return This function promoted to return its result on the right side of an Either.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
+    public static <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
         return o(Either.<C, B>right_(), f);
     }
 
@@ -281,7 +281,7 @@ static public <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
      * @return This function promoted to map over the left side of an Either.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
+    public static <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
         return Either.<A, X, B>leftMap_().f(f);
     }
 
@@ -291,7 +291,7 @@ static public <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
      * @return This function promoted to map over the right side of an Either.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B, X> F<Either<X, A>, Either<X, B>> mapRight(final F<A, B> f) {
+    public static <A, B, X> F<Either<X, A>, Either<X, B>> mapRight(final F<A, B> f) {
         return Either.<X, A, B>rightMap_().f(f);
     }
 
@@ -300,7 +300,7 @@ static public <A, B, X> F<Either<X, A>, Either<X, B>> mapRight(final F<A, B> f)
      *
      * @return a function that returns the left side of a given Either, or this function applied to the right side.
      */
-    static public <A, B> F<Either<B, A>, B> onLeft(final F<A, B> f) {
+    public static <A, B> F<Either<B, A>, B> onLeft(final F<A, B> f) {
         return e -> e.left().on(f);
     }
 
@@ -309,7 +309,7 @@ static public <A, B> F<Either<B, A>, B> onLeft(final F<A, B> f) {
      *
      * @return a function that returns the right side of a given Either, or this function applied to the left side.
      */
-    static public <A, B> F<Either<A, B>, B> onRight(final F<A, B> f) {
+    public static <A, B> F<Either<A, B>, B> onRight(final F<A, B> f) {
         return e -> e.right().on(f);
     }
 
@@ -319,7 +319,7 @@ static public <A, B> F<Either<A, B>, B> onRight(final F<A, B> f) {
      * @return This function promoted to return its value in an Iterable.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
+    public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
         return IterableW.<A, B>arrow().f(f);
     }
 
@@ -329,7 +329,7 @@ static public <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
      * @return This function promoted to map over Iterables.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
+    public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
         return F1Functions.o(IterableW.<A, B>map().f(f), IterableW.<A, Iterable<A>>wrap());
     }
 
@@ -339,7 +339,7 @@ static public <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
      * @return This function promoted to return its value in a NonEmptyList.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
+    public static <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
         return o(NonEmptyList.<B>nel(), f);
     }
 
@@ -348,7 +348,7 @@ static public <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
      *
      * @return This function promoted to map over a NonEmptyList.
      */
-    static public <A, B> F<NonEmptyList<A>, NonEmptyList<B>> mapNel(final F<A, B> f) {
+    public static <A, B> F<NonEmptyList<A>, NonEmptyList<B>> mapNel(final F<A, B> f) {
         return list -> list.map(f);
     }
 
@@ -358,7 +358,7 @@ static public <A, B> F<NonEmptyList<A>, NonEmptyList<B>> mapNel(final F<A, B> f)
      * @param o An order for the set.
      * @return This function promoted to return its value in a Set.
      */
-    static public <A, B> F<A, Set<B>> setK(final F<A, B> f, final Ord<B> o
+    public static <A, B> F<A, Set<B>> setK(final F<A, B> f, final Ord<B> o
     ) {
         return a -> Set.single(o, f.f(a));
     }
@@ -369,7 +369,7 @@ static public <A, B> F<A, Set<B>> setK(final F<A, B> f, final Ord<B> o
      * @param o An order for the resulting set.
      * @return This function promoted to map over a Set.
      */
-    static public <A, B> F<Set<A>, Set<B>> mapSet(final F<A, B> f, final Ord<B> o) {
+    public static <A, B> F<Set<A>, Set<B>> mapSet(final F<A, B> f, final Ord<B> o) {
         return s -> s.map(o, f);
     }
 
@@ -378,7 +378,7 @@ static public <A, B> F<Set<A>, Set<B>> mapSet(final F<A, B> f, final Ord<B> o) {
      *
      * @return This function promoted to return its value in a Tree.
      */
-    static public <A, B> F<A, Tree<B>> treeK(final F<A, B> f) {
+    public static <A, B> F<A, Tree<B>> treeK(final F<A, B> f) {
         return a -> Tree.leaf(f.f(a));
     }
 
@@ -388,7 +388,7 @@ static public <A, B> F<A, Tree<B>> treeK(final F<A, B> f) {
      * @return This function promoted to map over a Tree.
      */
     @SuppressWarnings({"unchecked"})
-    static public <A, B> F<Tree<A>, Tree<B>> mapTree(final F<A, B> f) {
+    public static <A, B> F<Tree<A>, Tree<B>> mapTree(final F<A, B> f) {
         return Tree.<A, B>fmap_().f(f);
     }
 
@@ -398,7 +398,7 @@ static public <A, B> F<Tree<A>, Tree<B>> mapTree(final F<A, B> f) {
      * @param m The monoid with which to fold the mapped tree.
      * @return a function that maps this function over a tree and folds it with the given monoid.
      */
-    static public <A, B> F<Tree<A>, B> foldMapTree(final F<A, B> f, final Monoid<B> m) {
+    public static <A, B> F<Tree<A>, B> foldMapTree(final F<A, B> f, final Monoid<B> m) {
         return Tree.foldMap_(f, m);
     }
 
@@ -407,7 +407,7 @@ static public <A, B> F<Tree<A>, B> foldMapTree(final F<A, B> f, final Monoid<B>
      *
      * @return This function promoted to return its value in a TreeZipper.
      */
-    static public <A, B> F<A, TreeZipper<B>> treeZipperK(final F<A, B> f) {
+    public static <A, B> F<A, TreeZipper<B>> treeZipperK(final F<A, B> f) {
         return andThen(treeK(f), TreeZipper.<B>fromTree());
     }
 
@@ -416,7 +416,7 @@ static public <A, B> F<A, TreeZipper<B>> treeZipperK(final F<A, B> f) {
      *
      * @return This function promoted to map over a TreeZipper.
      */
-    static public <A, B> F<TreeZipper<A>, TreeZipper<B>> mapTreeZipper(final F<A, B> f) {
+    public static <A, B> F<TreeZipper<A>, TreeZipper<B>> mapTreeZipper(final F<A, B> f) {
         return (z) -> z.map(f);
     }
 
@@ -426,7 +426,7 @@ static public <A, B> F<TreeZipper<A>, TreeZipper<B>> mapTreeZipper(final F<A, B>
      *
      * @return This function promoted to return its result on the failure side of a Validation.
      */
-    static public <A, B, C> F<A, Validation<B, C>> failK(final F<A, B> f) {
+    public static <A, B, C> F<A, Validation<B, C>> failK(final F<A, B> f) {
         return a -> Validation.fail(f.f(a));
 
     }
@@ -437,7 +437,7 @@ static public <A, B, C> F<A, Validation<B, C>> failK(final F<A, B> f) {
      *
      * @return This function promoted to return its result on the success side of an Validation.
      */
-    static public <A, B, C> F<A, Validation<C, B>> successK(final F<A, B> f) {
+    public static <A, B, C> F<A, Validation<C, B>> successK(final F<A, B> f) {
         return a -> Validation.success(f.f(a));
     }
 
@@ -446,7 +446,7 @@ static public <A, B, C> F<A, Validation<C, B>> successK(final F<A, B> f) {
      *
      * @return This function promoted to map over the failure side of a Validation.
      */
-    static public <A, B, X> F<Validation<A, X>, Validation<B, X>> mapFail(final F<A, B> f) {
+    public static <A, B, X> F<Validation<A, X>, Validation<B, X>> mapFail(final F<A, B> f) {
         return v -> v.f().map(f);
     }
 
@@ -455,7 +455,7 @@ static public <A, B, X> F<Validation<A, X>, Validation<B, X>> mapFail(final F<A,
      *
      * @return This function promoted to map over the success side of a Validation.
      */
-    static public <A, B, X> F<Validation<X, A>, Validation<X, B>> mapSuccess(final F<A, B> f) {
+    public static <A, B, X> F<Validation<X, A>, Validation<X, B>> mapSuccess(final F<A, B> f) {
         return v -> v.map(f);
     }
 
@@ -466,7 +466,7 @@ static public <A, B, X> F<Validation<X, A>, Validation<X, B>> mapSuccess(final F
      * @return a function that returns the failure side of a given Validation,
      *         or this function applied to the success side.
      */
-    static public <A, B> F<Validation<B, A>, B> onFail(final F<A, B> f) {
+    public static <A, B> F<Validation<B, A>, B> onFail(final F<A, B> f) {
         return v -> v.f().on(f);
     }
 
@@ -477,7 +477,7 @@ static public <A, B> F<Validation<B, A>, B> onFail(final F<A, B> f) {
      * @return a function that returns the success side of a given Validation,
      *         or this function applied to the failure side.
      */
-    static public <A, B> F<Validation<A, B>, B> onSuccess(final F<A, B> f) {
+    public static <A, B> F<Validation<A, B>, B> onSuccess(final F<A, B> f) {
         return v -> v.on(f);
     }
 
@@ -486,7 +486,7 @@ static public <A, B> F<Validation<A, B>, B> onSuccess(final F<A, B> f) {
      *
      * @return This function promoted to return its value in a Zipper.
      */
-    static public <A, B> F<A, Zipper<B>> zipperK(final F<A, B> f) {
+    public static <A, B> F<A, Zipper<B>> zipperK(final F<A, B> f) {
         return andThen(streamK(f), s -> fromStream(s).some());
     }
 
@@ -495,7 +495,7 @@ static public <A, B> F<A, Zipper<B>> zipperK(final F<A, B> f) {
      *
      * @return This function promoted to map over a Zipper.
      */
-    static public <A, B> F<Zipper<A>, Zipper<B>> mapZipper(final F<A, B> f) {
+    public static <A, B> F<Zipper<A>, Zipper<B>> mapZipper(final F<A, B> f) {
         return z -> z.map(f);
     }
 
@@ -504,7 +504,7 @@ static public <A, B> F<Zipper<A>, Zipper<B>> mapZipper(final F<A, B> f) {
      *
      * @return This function promoted to map over an Equal as a contravariant functor.
      */
-    static public <A, B> F<Equal<B>, Equal<A>> contramapEqual(final F<A, B> f) {
+    public static <A, B> F<Equal<B>, Equal<A>> contramapEqual(final F<A, B> f) {
         return e -> e.contramap(f);
     }
 
@@ -513,7 +513,7 @@ static public <A, B> F<Equal<B>, Equal<A>> contramapEqual(final F<A, B> f) {
      *
      * @return This function promoted to map over a Hash as a contravariant functor.
      */
-    static public <A, B> F<Hash<B>, Hash<A>> contramapHash(final F<A, B> f) {
+    public static <A, B> F<Hash<B>, Hash<A>> contramapHash(final F<A, B> f) {
         return h -> h.contramap(f);
     }
 
@@ -522,7 +522,7 @@ static public <A, B> F<Hash<B>, Hash<A>> contramapHash(final F<A, B> f) {
      *
      * @return This function promoted to map over a Show as a contravariant functor.
      */
-    static public <A, B> F<Show<B>, Show<A>> contramapShow(final F<A, B> f) {
+    public static <A, B> F<Show<B>, Show<A>> contramapShow(final F<A, B> f) {
         return s -> s.contramap(f);
     }
 
@@ -531,7 +531,7 @@ static public <A, B> F<Show<B>, Show<A>> contramapShow(final F<A, B> f) {
      *
      * @return This function promoted to map over the first element of a pair.
      */
-    static public <A, B, C> F<P2<A, C>, P2<B, C>> mapFst(final F<A, B> f) {
+    public static <A, B, C> F<P2<A, C>, P2<B, C>> mapFst(final F<A, B> f) {
         return P2.map1_(f);
     }
 
@@ -540,7 +540,7 @@ static public <A, B, C> F<P2<A, C>, P2<B, C>> mapFst(final F<A, B> f) {
      *
      * @return This function promoted to map over the second element of a pair.
      */
-    static public <A, B, C> F<P2<C, A>, P2<C, B>> mapSnd(final F<A, B> f) {
+    public static <A, B, C> F<P2<C, A>, P2<C, B>> mapSnd(final F<A, B> f) {
         return P2.map2_(f);
     }
 
@@ -549,7 +549,7 @@ static public <A, B, C> F<P2<C, A>, P2<C, B>> mapSnd(final F<A, B> f) {
      *
      * @return This function promoted to map over both elements of a pair.
      */
-    static public <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
+    public static <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
         return p2 -> P2.map(f, p2);
     }
 
@@ -559,7 +559,7 @@ static public <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
      * @param as A SynchronousQueue to map this function over.
      * @return A new SynchronousQueue with this function applied to each element.
      */
-    static public <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final SynchronousQueue<A> as) {
+    public static <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final SynchronousQueue<A> as) {
         final SynchronousQueue<B> bs = new SynchronousQueue<B>();
         bs.addAll(iterableStream(as).map(f).toCollection());
         return bs;
@@ -572,7 +572,7 @@ static public <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final Synchronous
      * @param as A PriorityBlockingQueue to map this function over.
      * @return A new PriorityBlockingQueue with this function applied to each element.
      */
-    static public <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final PriorityBlockingQueue<A> as) {
+    public static <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final PriorityBlockingQueue<A> as) {
         return new PriorityBlockingQueue<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -582,7 +582,7 @@ static public <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final Priori
      * @param as A LinkedBlockingQueue to map this function over.
      * @return A new LinkedBlockingQueue with this function applied to each element.
      */
-    static public <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBlockingQueue<A> as) {
+    public static <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBlockingQueue<A> as) {
         return new LinkedBlockingQueue<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -592,7 +592,7 @@ static public <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBl
      * @param as A CopyOnWriteArraySet to map this function over.
      * @return A new CopyOnWriteArraySet with this function applied to each element.
      */
-    static public <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWriteArraySet<A> as) {
+    public static <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWriteArraySet<A> as) {
         return new CopyOnWriteArraySet<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -602,7 +602,7 @@ static public <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWr
      * @param as A CopyOnWriteArrayList to map this function over.
      * @return A new CopyOnWriteArrayList with this function applied to each element.
      */
-    static public <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnWriteArrayList<A> as) {
+    public static <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnWriteArrayList<A> as) {
         return new CopyOnWriteArrayList<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -612,7 +612,7 @@ static public <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnW
      * @param as A ConcurrentLinkedQueue to map this function over.
      * @return A new ConcurrentLinkedQueue with this function applied to each element.
      */
-    static public <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final ConcurrentLinkedQueue<A> as) {
+    public static <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final ConcurrentLinkedQueue<A> as) {
         return new ConcurrentLinkedQueue<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -622,7 +622,7 @@ static public <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final Concur
      * @param as An ArrayBlockingQueue to map this function over.
      * @return A new ArrayBlockingQueue with this function applied to each element.
      */
-    static public <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBlockingQueue<A> as) {
+    public static <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBlockingQueue<A> as) {
         final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<B>(as.size());
         bs.addAll(iterableStream(as).map(f).toCollection());
         return bs;
@@ -635,7 +635,7 @@ static public <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBloc
      * @param as A TreeSet to map this function over.
      * @return A new TreeSet with this function applied to each element.
      */
-    static public <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
+    public static <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
         return new TreeSet<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -645,7 +645,7 @@ static public <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
      * @param as A PriorityQueue to map this function over.
      * @return A new PriorityQueue with this function applied to each element.
      */
-    static public <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<A> as) {
+    public static <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<A> as) {
         return new PriorityQueue<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -655,7 +655,7 @@ static public <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<
      * @param as A LinkedList to map this function over.
      * @return A new LinkedList with this function applied to each element.
      */
-    static public <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as) {
+    public static <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as) {
         return new LinkedList<B>(iterableStream(as).map(f).toCollection());
     }
 
@@ -665,15 +665,15 @@ static public <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as)
      * @param as An ArrayList to map this function over.
      * @return A new ArrayList with this function applied to each element.
      */
-    static public <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
+    public static <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
         return new ArrayList<B>(iterableStream(as).map(f).toCollection());
     }
 
-    static public <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {
+    public static <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {
         return andThen(target, f);
     }
 
-    static public <A, B, C> F<C, B> contramap(F<A, B> target, F<C, A> f) {
+    public static <A, B, C> F<C, B> contramap(F<A, B> target, F<C, A> f) {
         return andThen(f, target);
     }
 
diff --git a/core/src/main/java/fj/F2Functions.java b/core/src/main/java/fj/F2Functions.java
index 9ce1cc0a..f69e02ed 100644
--- a/core/src/main/java/fj/F2Functions.java
+++ b/core/src/main/java/fj/F2Functions.java
@@ -25,7 +25,7 @@ private F2Functions() {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument.
      */
-    static public <A, B, C> F<B, C> f(final F2<A, B, C> f, final A a) {
+  public static <A, B, C> F<B, C> f(final F2<A, B, C> f, final A a) {
         return b -> f.f(a, b);
     }
 
@@ -34,7 +34,7 @@ static public <A, B, C> F<B, C> f(final F2<A, B, C> f, final A a) {
      *
      * @return a wrapped function of arity-1 that returns another wrapped function.
      */
-    static public <A, B, C> F<A, F<B, C>> curry(final F2<A, B, C> f) {
+    public static <A, B, C> F<A, F<B, C>> curry(final F2<A, B, C> f) {
         return a -> b -> f.f(a, b);
     }
 
@@ -43,7 +43,7 @@ static public <A, B, C> F<A, F<B, C>> curry(final F2<A, B, C> f) {
      *
      * @return A new function with the arguments of this function flipped.
      */
-    static public <A, B, C> F2<B, A, C> flip(final F2<A, B, C> f) {
+    public static <A, B, C> F2<B, A, C> flip(final F2<A, B, C> f) {
         return (b, a) -> f.f(a, b);
     }
 
@@ -52,7 +52,7 @@ static public <A, B, C> F2<B, A, C> flip(final F2<A, B, C> f) {
      *
      * @return A new function that calls this function with the elements of a given tuple.
      */
-    static public <A, B, C> F<P2<A, B>, C> tuple(final F2<A, B, C> f) {
+    public static <A, B, C> F<P2<A, B>, C> tuple(final F2<A, B, C> f) {
         return p -> f.f(p._1(), p._2());
     }
 
@@ -61,7 +61,7 @@ static public <A, B, C> F<P2<A, B>, C> tuple(final F2<A, B, C> f) {
      *
      * @return This function promoted to transform Arrays.
      */
-    static public <A, B, C> F2<Array<A>, Array<B>, Array<C>> arrayM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Array<A>, Array<B>, Array<C>> arrayM(final F2<A, B, C> f) {
         return (a, b) -> a.bind(b, curry(f));
     }
 
@@ -70,7 +70,7 @@ static public <A, B, C> F2<Array<A>, Array<B>, Array<C>> arrayM(final F2<A, B, C
      *
      * @return This function promoted to transform Promises.
      */
-    static public <A, B, C> F2<Promise<A>, Promise<B>, Promise<C>> promiseM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Promise<A>, Promise<B>, Promise<C>> promiseM(final F2<A, B, C> f) {
         return (a, b) -> a.bind(b, curry(f));
     }
 
@@ -79,7 +79,7 @@ static public <A, B, C> F2<Promise<A>, Promise<B>, Promise<C>> promiseM(final F2
      *
      * @return This function promoted to transform Iterables.
      */
-    static public <A, B, C> F2<Iterable<A>, Iterable<B>, IterableW<C>> iterableM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Iterable<A>, Iterable<B>, IterableW<C>> iterableM(final F2<A, B, C> f) {
         return (a, b) -> IterableW.liftM2(curry(f)).f(a).f(b);
     }
 
@@ -88,7 +88,7 @@ static public <A, B, C> F2<Iterable<A>, Iterable<B>, IterableW<C>> iterableM(fin
      *
      * @return This function promoted to transform Lists.
      */
-    static public <A, B, C> F2<List<A>, List<B>, List<C>> listM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<List<A>, List<B>, List<C>> listM(final F2<A, B, C> f) {
         return (a, b) -> List.liftM2(curry(f)).f(a).f(b);
     }
 
@@ -97,7 +97,7 @@ static public <A, B, C> F2<List<A>, List<B>, List<C>> listM(final F2<A, B, C> f)
      *
      * @return This function promoted to transform non-empty lists.
      */
-    static public <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM(final F2<A, B, C> f) {
         return (as, bs) -> NonEmptyList.fromList(as.toList().bind(bs.toList(), f)).some();
     }
 
@@ -106,7 +106,7 @@ static public <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> ne
      *
      * @return This function promoted to transform Options.
      */
-    static public <A, B, C> F2<Option<A>, Option<B>, Option<C>> optionM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Option<A>, Option<B>, Option<C>> optionM(final F2<A, B, C> f) {
         return (a, b) -> Option.liftM2(curry(f)).f(a).f(b);
     }
 
@@ -116,7 +116,7 @@ static public <A, B, C> F2<Option<A>, Option<B>, Option<C>> optionM(final F2<A,
      * @param o An ordering for the result of the promoted function.
      * @return This function promoted to transform Sets.
      */
-    static public <A, B, C> F2<Set<A>, Set<B>, Set<C>> setM(final F2<A, B, C> f, final Ord<C> o) {
+    public static <A, B, C> F2<Set<A>, Set<B>, Set<C>> setM(final F2<A, B, C> f, final Ord<C> o) {
         return (as, bs) -> {
             Set<C> cs = Set.empty(o);
             for (final A a : as)
@@ -131,7 +131,7 @@ static public <A, B, C> F2<Set<A>, Set<B>, Set<C>> setM(final F2<A, B, C> f, fin
      *
      * @return This function promoted to transform Streams.
      */
-    static public <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> streamM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> streamM(final F2<A, B, C> f) {
         return (as, bs) -> as.bind(bs, f);
     }
 
@@ -140,7 +140,7 @@ static public <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> streamM(final F2<A,
      *
      * @return This function promoted to transform Trees.
      */
-    static public <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> treeM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> treeM(final F2<A, B, C> f) {
         return new F2<Tree<A>, Tree<B>, Tree<C>>() {
             public Tree<C> f(final Tree<A> as, final Tree<B> bs) {
                 final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
@@ -154,7 +154,7 @@ public Tree<C> f(final Tree<A> as, final Tree<B> bs) {
      *
      * @return A function that zips two arrays with this function.
      */
-    static public <A, B, C> F2<Array<A>, Array<B>, Array<C>> zipArrayM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Array<A>, Array<B>, Array<C>> zipArrayM(final F2<A, B, C> f) {
         return (as, bs) -> as.zipWith(bs, f);
     }
 
@@ -163,7 +163,7 @@ static public <A, B, C> F2<Array<A>, Array<B>, Array<C>> zipArrayM(final F2<A, B
      *
      * @return A function that zips two iterables with this function.
      */
-    static public <A, B, C> F2<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM(final F2<A, B, C> f) {
         return (as, bs) -> wrap(as).zipWith(bs, f);
     }
 
@@ -172,7 +172,7 @@ static public <A, B, C> F2<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM(f
      *
      * @return A function that zips two lists with this function.
      */
-    static public <A, B, C> F2<List<A>, List<B>, List<C>> zipListM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<List<A>, List<B>, List<C>> zipListM(final F2<A, B, C> f) {
         return (as, bs) -> as.zipWith(bs, f);
     }
 
@@ -182,7 +182,7 @@ static public <A, B, C> F2<List<A>, List<B>, List<C>> zipListM(final F2<A, B, C>
      *
      * @return A function that zips two streams with this function.
      */
-    static public <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> zipStreamM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> zipStreamM(final F2<A, B, C> f) {
         return (as, bs) -> as.zipWith(bs, f);
     }
 
@@ -191,7 +191,7 @@ static public <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> zipStreamM(final F2<
      *
      * @return A function that zips two non-empty lists with this function.
      */
-    static public <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM(final F2<A, B, C> f) {
         return (as, bs) -> NonEmptyList.fromList(as.toList().zipWith(bs.toList(), f)).some();
     }
 
@@ -201,7 +201,7 @@ static public <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zi
      * @param o An ordering for the resulting set.
      * @return A function that zips two sets with this function.
      */
-    static public <A, B, C> F2<Set<A>, Set<B>, Set<C>> zipSetM(final F2<A, B, C> f, final Ord<C> o) {
+    public static <A, B, C> F2<Set<A>, Set<B>, Set<C>> zipSetM(final F2<A, B, C> f, final Ord<C> o) {
         return (as, bs) -> iterableSet(o, as.toStream().zipWith(bs.toStream(), f));
     }
 
@@ -211,7 +211,7 @@ static public <A, B, C> F2<Set<A>, Set<B>, Set<C>> zipSetM(final F2<A, B, C> f,
      *
      * @return A function that zips two trees with this function.
      */
-    static public <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> zipTreeM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> zipTreeM(final F2<A, B, C> f) {
         return new F2<Tree<A>, Tree<B>, Tree<C>>() {
             public Tree<C> f(final Tree<A> ta, final Tree<B> tb) {
                 final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
@@ -226,7 +226,7 @@ public Tree<C> f(final Tree<A> ta, final Tree<B> tb) {
      *
      * @return A function that zips two zippers with this function.
      */
-    static public <A, B, C> F2<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM(final F2<A, B, C> f) {
         return (ta, tb) -> {
             final F2<Stream<A>, Stream<B>, Stream<C>> sf = zipStreamM(f);
             return zipper(sf.f(ta.lefts(), tb.lefts()), f.f(ta.focus(), tb.focus()), sf.f(ta.rights(), tb.rights()));
@@ -239,7 +239,7 @@ static public <A, B, C> F2<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM(final F2<
      *
      * @return A function that zips two TreeZippers with this function.
      */
-    static public <A, B, C> F2<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM(final F2<A, B, C> f) {
+    public static <A, B, C> F2<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM(final F2<A, B, C> f) {
         return (ta, tb) -> {
             final F2<Stream<Tree<A>>, Stream<Tree<B>>, Stream<Tree<C>>> sf = zipStreamM(treeM(f));
             final
@@ -254,19 +254,19 @@ static public <A, B, C> F2<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZ
         };
     }
 
-    static public <A, B, C, Z> F2<Z, B, C> contramapFirst(F2<A, B, C> target, F<Z, A> f) {
+    public static <A, B, C, Z> F2<Z, B, C> contramapFirst(F2<A, B, C> target, F<Z, A> f) {
         return (z, b) -> target.f(f.f(z), b);
     }
 
-    static public <A, B, C, Z> F2<A, Z, C> contramapSecond(F2<A, B, C> target, F<Z, B> f) {
+    public static <A, B, C, Z> F2<A, Z, C> contramapSecond(F2<A, B, C> target, F<Z, B> f) {
         return (a, z) -> target.f(a, f.f(z));
     }
 
-    static public <A, B, C, X, Y> F2<X, Y, C> contramap(F2<A, B, C> target, F<X, A> f, F<Y, B> g) {
+    public static <A, B, C, X, Y> F2<X, Y, C> contramap(F2<A, B, C> target, F<X, A> f, F<Y, B> g) {
         return contramapSecond(contramapFirst(target, f), g);
     }
 
-    static public <A, B, C, Z> F2<A, B, Z> map(F2<A, B, C> target, F<C, Z> f) {
+    public static <A, B, C, Z> F2<A, B, Z> map(F2<A, B, C> target, F<C, Z> f) {
         return (a, b) -> f.f(target.f(a, b));
     }
 
diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
index 77a8fa74..a1e0b8f7 100644
--- a/core/src/main/java/fj/F3Functions.java
+++ b/core/src/main/java/fj/F3Functions.java
@@ -21,7 +21,7 @@ private F3Functions() {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument.
      */
-    static public <A, B, C, D> F2<B, C, D> f(final F3<A, B, C, D> f, final A a) {
+  public static <A, B, C, D> F2<B, C, D> f(final F3<A, B, C, D> f, final A a) {
         return (b, c) -> f.f(a, b, c);
     }
 
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
index ab57247b..04525167 100644
--- a/core/src/main/java/fj/F4Functions.java
+++ b/core/src/main/java/fj/F4Functions.java
@@ -17,7 +17,7 @@ private F4Functions() {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument.
      */
-    static public <A, B, C, D, E> F3<B, C, D, E> f(final F4<A, B, C, D, E> f, final A a) {
+  public static <A, B, C, D, E> F3<B, C, D, E> f(final F4<A, B, C, D, E> f, final A a) {
         return (b, c, d) -> f.f(a, b, c, d);
     }
 
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
index 6345de01..d8dda4da 100644
--- a/core/src/main/java/fj/F5Functions.java
+++ b/core/src/main/java/fj/F5Functions.java
@@ -17,7 +17,7 @@ private F5Functions() {
 	 * @param a The <code>A</code> to which to apply this function.
 	 * @return The function partially applied to the given argument.
 	 */
-	static public <A, B, C, D, E, F$> F4<B, C, D, E, F$> f(final F5<A, B, C, D, E, F$> f, final A a) {
+	public static <A, B, C, D, E, F$> F4<B, C, D, E, F$> f(final F5<A, B, C, D, E, F$> f, final A a) {
 		return (b, c, d, e) -> f.f(a, b, c, d, e);
 	}
 
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
index 19269e40..69ce270a 100644
--- a/core/src/main/java/fj/F6Functions.java
+++ b/core/src/main/java/fj/F6Functions.java
@@ -17,7 +17,7 @@ private F6Functions() {
 	 * @param a The <code>A</code> to which to apply this function.
 	 * @return The function partially applied to the given argument.
 	 */
-	static public <A, B, C, D, E, F$, G> F5<B, C, D, E, F$, G> f(final F6<A, B, C, D, E, F$, G> func, final A a) {
+	public static <A, B, C, D, E, F$, G> F5<B, C, D, E, F$, G> f(final F6<A, B, C, D, E, F$, G> func, final A a) {
 		return (b, c, d, e, f) -> func.f(a, b, c, d, e, f);
 	}
 
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
index 4abcb986..0f2f25ac 100644
--- a/core/src/main/java/fj/F7Functions.java
+++ b/core/src/main/java/fj/F7Functions.java
@@ -17,7 +17,7 @@ private F7Functions() {
 	 * @param a The <code>A</code> to which to apply this function.
 	 * @return The function partially applied to the given argument.
 	 */
-	static public <A, B, C, D, E, F$, G, H> F6<B, C, D, E, F$, G, H> f(final F7<A, B, C, D, E, F$, G, H> func, final A a) {
+	public static <A, B, C, D, E, F$, G, H> F6<B, C, D, E, F$, G, H> f(final F7<A, B, C, D, E, F$, G, H> func, final A a) {
 		return (b, c, d, e, f, g) -> func.f(a, b, c, d, e, f, g);
 	}
 
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
index 5cb9bb3b..5eafe1f3 100644
--- a/core/src/main/java/fj/F8Functions.java
+++ b/core/src/main/java/fj/F8Functions.java
@@ -17,7 +17,7 @@ private F8Functions() {
 	 * @param a The <code>A</code> to which to apply this function.
 	 * @return The function partially applied to the given argument.
 	 */
-	static public <A, B, C, D, E, F$, G, H, I> F7<B, C, D, E, F$, G, H, I> f(final F8<A, B, C, D, E, F$, G, H, I> func, final A a) {
+	public static <A, B, C, D, E, F$, G, H, I> F7<B, C, D, E, F$, G, H, I> f(final F8<A, B, C, D, E, F$, G, H, I> func, final A a) {
 		return (b, c, d, e, f, g, h) -> func.f(a, b, c, d, e, f, g, h);
 	}
 
diff --git a/core/src/main/java/fj/Try.java b/core/src/main/java/fj/Try.java
index c5829b01..d18d7dbd 100644
--- a/core/src/main/java/fj/Try.java
+++ b/core/src/main/java/fj/Try.java
@@ -25,7 +25,7 @@ private Try() {
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, E extends Exception> P1<Validation<E, A>> f(final Try0<A, E> t) {
+    public static <A, E extends Exception> P1<Validation<E, A>> f(final Try0<A, E> t) {
         return P.lazy(() -> {
             try {
                 return success(t.f());
@@ -42,7 +42,7 @@ static public <A, E extends Exception> P1<Validation<E, A>> f(final Try0<A, E> t
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, E extends Exception> F<A, Validation<E, B>> f(final Try1<A, B, E> t) {
+    public static <A, B, E extends Exception> F<A, Validation<E, B>> f(final Try1<A, B, E> t) {
         return a -> {
             try {
                 return Validation.success(t.f(a));
@@ -59,7 +59,7 @@ static public <A, B, E extends Exception> F<A, Validation<E, B>> f(final Try1<A,
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, E extends Exception> F2<A, B, Validation<E, C>> f(final Try2<A, B, C, E> t) {
+    public static <A, B, C, E extends Exception> F2<A, B, Validation<E, C>> f(final Try2<A, B, C, E> t) {
         return (a, b) -> {
             try {
                 return success(t.f(a, b));
@@ -76,7 +76,7 @@ static public <A, B, C, E extends Exception> F2<A, B, Validation<E, C>> f(final
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, D, E extends Exception> F3<A, B, C, Validation<E, D>> f(final Try3<A, B, C, D, E> t) {
+    public static <A, B, C, D, E extends Exception> F3<A, B, C, Validation<E, D>> f(final Try3<A, B, C, D, E> t) {
         return (a, b, c) -> {
             try {
                 return success(t.f(a, b, c));
@@ -93,7 +93,7 @@ static public <A, B, C, D, E extends Exception> F3<A, B, C, Validation<E, D>> f(
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(final Try4<A, B, C, D, E, Z> t) {
+    public static <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z, E>> f(final Try4<A, B, C, D, E, Z> t) {
         return (a, b, c, d) -> {
             try {
                 return success(t.f(a, b, c, d));
@@ -110,7 +110,7 @@ static public <A, B, C, D, E, Z extends Exception> F4<A, B, C, D, Validation<Z,
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, D, E, F, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F>> f(final Try5<A, B, C, D, E, F, Z> t) {
+    public static <A, B, C, D, E, F, Z extends Exception> F5<A, B, C, D, E, Validation<Z, F>> f(final Try5<A, B, C, D, E, F, Z> t) {
         return (a, b, c, d, e) -> {
             try {
                 return success(t.f(a, b, c, d, e));
@@ -127,7 +127,7 @@ static public <A, B, C, D, E, F, Z extends Exception> F5<A, B, C, D, E, Validati
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, D, E, F, G, Z extends Exception> F6<A, B, C, D, E, F, Validation<Z, G>> f(final Try6<A, B, C, D, E, F, G, Z> t) {
+    public static <A, B, C, D, E, F, G, Z extends Exception> F6<A, B, C, D, E, F, Validation<Z, G>> f(final Try6<A, B, C, D, E, F, G, Z> t) {
         return (a, b, c, d, e, f) -> {
             try {
                 return success(t.f(a, b, c, d, e, f));
@@ -144,7 +144,7 @@ static public <A, B, C, D, E, F, G, Z extends Exception> F6<A, B, C, D, E, F, Va
      * @return A Validation with an Exception on the failure side and its result on the success side.
      */
     @SuppressWarnings("unchecked")
-    static public <A, B, C, D, E, F, G, H, Z extends Exception> F7<A, B, C, D, E, F, G, Validation<Z, H>> f(final Try7<A, B, C, D, E, F, G, H, Z> t) {
+    public static <A, B, C, D, E, F, G, H, Z extends Exception> F7<A, B, C, D, E, F, G, Validation<Z, H>> f(final Try7<A, B, C, D, E, F, G, H, Z> t) {
         return (a, b, c, d, e, f, g) -> {
             try {
                 return success(t.f(a, b, c, d, e, f, g));
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index f609fb0f..49b6bb61 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -15,7 +15,7 @@ public abstract class Trampoline<A> {
 
   // A Normal Trampoline is either done or suspended, and is allowed to be a subcomputation of a Codense.
   // This is the pointed functor part of the Trampoline monad.
-  private static abstract class Normal<A> extends Trampoline<A> {
+  private abstract static class Normal<A> extends Trampoline<A> {
     public abstract <R> R foldNormal(final F<A, R> pure, final F<P1<Trampoline<A>>, R> k);
 
     public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
diff --git a/core/src/main/java/fj/data/Conversions.java b/core/src/main/java/fj/data/Conversions.java
index 5405f70a..f6cfb624 100644
--- a/core/src/main/java/fj/data/Conversions.java
+++ b/core/src/main/java/fj/data/Conversions.java
@@ -616,7 +616,7 @@ public static <A, B, Z extends IOException> F<Try1<A, B, Z>, F<A, Validation<Z,
 
     // BEGIN TryEffect
 
-    static public <E extends Exception> P1<Validation<E, Unit>> TryEffect_P(final TryEffect0<E> t) {
+    public static <E extends Exception> P1<Validation<E, Unit>> TryEffect_P(final TryEffect0<E> t) {
         return TryEffect.f(t);
     }
 
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index e4cd3530..7b413293 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -15,7 +15,7 @@
 public final class Iteratee {
 
   /** The input to an iteratee. */
-  public static abstract class Input<E> {
+  public abstract static class Input<E> {
 
     Input() {} // sealed
 
@@ -53,7 +53,7 @@ public <Z> Z apply(final F0<Z> empty, final F0<F<E, Z>> el, final F0<Z> eof) {
   }
 
   /** A pure iteratee computation which is either done or needs more input */
-  public static abstract class IterV<E, A> {
+  public abstract static class IterV<E, A> {
 
     IterV() {} // sealed
 
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
index 03e310d2..93fd1e9e 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/java8/src/main/java/fj/data/Java8.java
@@ -75,27 +75,27 @@ public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {
         return f -> (a, b) -> f.f(a, b);
     }
 
-    static public <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
+    public static <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
         return Java8.<A, E>TryCatch0_Supplier().f(t);
     }
 
-    static public <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
+    public static <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
         return t -> () -> Try.f(t)._1();
     }
 
-    static public <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {
+    public static <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {
         return Java8.<A, B, E>TryCatch1_Function().f(t);
     }
 
-    static public <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
+    public static <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
         return t -> a -> Try.f(t).f(a);
     }
 
-    static public <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {
+    public static <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {
         return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);
     }
 
-    static public <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
+    public static <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
         return t -> (a, b) -> Try.f(t).f(a, b);
     }
 
@@ -103,23 +103,23 @@ public static <A> java.util.stream.Stream<A> List_JavaStream(final List<A> list)
         return Iterable_JavaStream(list);
     }
 
-    static public <A> Option<A> Optional_Option(final Optional<A> o) {
+    public static <A> Option<A> Optional_Option(final Optional<A> o) {
         return Java8.<A>Optional_Option().f(o);
     }
 
-    static public <A> F<Optional<A>, Option<A>> Optional_Option() {
+    public static <A> F<Optional<A>, Option<A>> Optional_Option() {
         return o -> o.isPresent() ? Option.fromNull(o.get()) : Option.none();
     }
 
-    static public <A> Optional<A> Option_Optional(final Option<A> o) {
+    public static <A> Optional<A> Option_Optional(final Option<A> o) {
         return Java8.<A>Option_Optional().f(o);
     }
 
-    static public <A> F<Option<A>, Optional<A>> Option_Optional() {
+    public static <A> F<Option<A>, Optional<A>> Option_Optional() {
         return o -> o.isSome() ? Optional.ofNullable(o.some()) : Optional.empty();
     }
 
-    static public <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {
+    public static <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {
         return c -> Consumer_F(c);
     }
 
@@ -130,31 +130,31 @@ public static <A> F<A, Unit> Consumer_F(final Consumer<A> c) {
         };
     }
 
-    static public <A> java.util.stream.Stream<A> Stream_JavaStream(final fj.data.Stream<A> s) {
+    public static <A> java.util.stream.Stream<A> Stream_JavaStream(final fj.data.Stream<A> s) {
         return Iterable_JavaStream(s);
     }
 
-    static public <A> java.util.stream.Stream<A> Iterable_JavaStream(final Iterable<A> it) {
+    public static <A> java.util.stream.Stream<A> Iterable_JavaStream(final Iterable<A> it) {
         return StreamSupport.stream(it.spliterator(), false);
     }
 
-    static public <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<A> it) {
+    public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<A> it) {
         return Iterable_JavaStream(() -> it);
     }
 
-    static public <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
+    public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
         return s -> Stream_JavaStream(s);
     }
 
-    static public <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {
+    public static <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {
         return s.collect(Collectors.toStream());
     }
 
-    static public <A> List<A> JavaStream_List(final java.util.stream.Stream<A> s) {
+    public static <A> List<A> JavaStream_List(final java.util.stream.Stream<A> s) {
         return s.collect(Collectors.toList());
     }
 
-    static public <A> Array<A> JavaStream_Array(final java.util.stream.Stream<A> s) {
+    public static <A> Array<A> JavaStream_Array(final java.util.stream.Stream<A> s) {
         return s.collect(Collectors.toArray());
     }
 

From 045471917902d4e4948a01804091f6cfc97b3cea Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 17:10:30 +0100
Subject: [PATCH 029/336] Simplify annotations

---
 core/src/main/java/fj/Bottom.java             |  2 +-
 core/src/main/java/fj/Class.java              |  2 +-
 core/src/main/java/fj/F1Functions.java        | 18 +++----
 core/src/main/java/fj/F1W.java                | 18 +++----
 core/src/main/java/fj/Monoid.java             |  2 +-
 core/src/main/java/fj/P6.java                 |  2 +-
 core/src/main/java/fj/P7.java                 |  2 +-
 core/src/main/java/fj/P8.java                 |  2 +-
 core/src/main/java/fj/data/$.java             |  2 +-
 core/src/main/java/fj/data/Array.java         | 16 +++---
 core/src/main/java/fj/data/HashMap.java       |  2 +-
 core/src/main/java/fj/data/IterableW.java     |  4 +-
 core/src/main/java/fj/data/List.java          |  8 +--
 core/src/main/java/fj/data/Option.java        |  4 +-
 core/src/main/java/fj/data/Set.java           |  4 +-
 core/src/main/java/fj/data/Stream.java        |  2 +-
 core/src/main/java/fj/data/TreeMap.java       |  2 +-
 core/src/main/java/fj/data/Validation.java    |  8 +--
 core/src/main/java/fj/data/Zipper.java        |  2 +-
 .../java/fj/demo/concurrent/PingPong.java     |  2 +-
 .../java/fj/demo/test/ListFunctorLaws.java    |  2 +-
 demo/src/main/java/fj/demo/test/Reflect.java  |  2 +-
 .../src/main/java/fj/test/Arbitrary.java      | 28 +++++------
 .../src/main/java/fj/test/CheckResult.java    |  2 +-
 .../src/main/java/fj/test/Coarbitrary.java    | 50 +++++++++----------
 .../src/main/java/fj/test/Property.java       |  4 +-
 quickcheck/src/main/java/fj/test/Result.java  |  2 +-
 quickcheck/src/main/java/fj/test/Shrink.java  |  4 +-
 .../src/main/java/fj/test/reflect/Check.java  |  4 +-
 29 files changed, 101 insertions(+), 101 deletions(-)

diff --git a/core/src/main/java/fj/Bottom.java b/core/src/main/java/fj/Bottom.java
index a9951928..0f828102 100644
--- a/core/src/main/java/fj/Bottom.java
+++ b/core/src/main/java/fj/Bottom.java
@@ -72,7 +72,7 @@ public static <A> Error decons(final A a, final Show<A> sa) {
    * @param c The type being deconstructed.
    * @return A deconstruction failure that was non-exhaustive.
    */
-  @SuppressWarnings({"UnnecessaryFullyQualifiedName"})
+  @SuppressWarnings("UnnecessaryFullyQualifiedName")
   public static <A> Error decons(final java.lang.Class<A> c) {
     return error("Deconstruction failure on type " + c);
   }
diff --git a/core/src/main/java/fj/Class.java b/core/src/main/java/fj/Class.java
index 6eac6e39..e2630569 100644
--- a/core/src/main/java/fj/Class.java
+++ b/core/src/main/java/fj/Class.java
@@ -39,7 +39,7 @@ public java.lang.Class<? super T> _1() {
                         return c2;
                       }
 
-                      @SuppressWarnings({"unchecked"})
+                      @SuppressWarnings("unchecked")
                       public java.lang.Class<? super T> _2() {
                         return c2.getSuperclass();
                       }
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 5821a893..12f565b2 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -49,7 +49,7 @@ public static <A, B,C> F<F<C, A>, F<C, B>> o(final F<A, B> f) {
      * @param g A function with which to compose this one.
      * @return The composed function such that this function is applied first.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B, C> F<A, C> andThen(final F<A, B> f, final F<B, C> g) {
         return o(g, f);
     }
@@ -259,7 +259,7 @@ public static <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
      *
      * @return This function promoted to return its result on the left side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
         return o(Either.<B, C>left_(), f);
     }
@@ -270,7 +270,7 @@ public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
      *
      * @return This function promoted to return its result on the right side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
         return o(Either.<C, B>right_(), f);
     }
@@ -280,7 +280,7 @@ public static <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
      *
      * @return This function promoted to map over the left side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
         return Either.<A, X, B>leftMap_().f(f);
     }
@@ -290,7 +290,7 @@ public static <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
      *
      * @return This function promoted to map over the right side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B, X> F<Either<X, A>, Either<X, B>> mapRight(final F<A, B> f) {
         return Either.<X, A, B>rightMap_().f(f);
     }
@@ -318,7 +318,7 @@ public static <A, B> F<Either<A, B>, B> onRight(final F<A, B> f) {
      *
      * @return This function promoted to return its value in an Iterable.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
         return IterableW.<A, B>arrow().f(f);
     }
@@ -328,7 +328,7 @@ public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
      *
      * @return This function promoted to map over Iterables.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
         return F1Functions.o(IterableW.<A, B>map().f(f), IterableW.<A, Iterable<A>>wrap());
     }
@@ -338,7 +338,7 @@ public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
      *
      * @return This function promoted to return its value in a NonEmptyList.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
         return o(NonEmptyList.<B>nel(), f);
     }
@@ -387,7 +387,7 @@ public static <A, B> F<A, Tree<B>> treeK(final F<A, B> f) {
      *
      * @return This function promoted to map over a Tree.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public static <A, B> F<Tree<A>, Tree<B>> mapTree(final F<A, B> f) {
         return Tree.<A, B>fmap_().f(f);
     }
diff --git a/core/src/main/java/fj/F1W.java b/core/src/main/java/fj/F1W.java
index 73545411..7fe50e35 100644
--- a/core/src/main/java/fj/F1W.java
+++ b/core/src/main/java/fj/F1W.java
@@ -41,7 +41,7 @@ public <C> F1W<F<C, A>, F<C, B>> o() {
      * @param g A function with which to compose this one.
      * @return The composed function such that this function is applied first.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public <C> F1W<A, C> andThen(final F<B, C> g) {
         return lift(F1Functions.andThen(this, g));
     }
@@ -254,7 +254,7 @@ public F1W<Promise<A>, Promise<B>> mapPromise() {
      *
      * @return This function promoted to return its result on the left side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public <C> F1W<A, Either<B, C>> eitherLeftK() {
         return lift(F1Functions.eitherLeftK(this));
     }
@@ -265,7 +265,7 @@ public <C> F1W<A, Either<B, C>> eitherLeftK() {
      *
      * @return This function promoted to return its result on the right side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public <C> F1W<A, Either<C, B>> eitherRightK() {
         return lift(F1Functions.eitherRightK(this));
     }
@@ -275,7 +275,7 @@ public <C> F1W<A, Either<C, B>> eitherRightK() {
      *
      * @return This function promoted to map over the left side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
         return lift(F1Functions.mapLeft(this));
     }
@@ -285,7 +285,7 @@ public <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
      *
      * @return This function promoted to map over the right side of an Either.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public <X> F1W<Either<X, A>, Either<X, B>> mapRight() {
         return lift(F1Functions.mapRight(this));
     }
@@ -313,7 +313,7 @@ public F1W<Either<A, B>, B> onRight() {
      *
      * @return This function promoted to return its value in an Iterable.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public F1W<A, IterableW<B>> iterableK() {
         return lift( F1Functions.iterableK(this));
     }
@@ -323,7 +323,7 @@ public F1W<A, IterableW<B>> iterableK() {
      *
      * @return This function promoted to map over Iterables.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public F1W<Iterable<A>, IterableW<B>> mapIterable() {
         return lift( F1Functions.mapIterable(this));
     }
@@ -333,7 +333,7 @@ public F1W<Iterable<A>, IterableW<B>> mapIterable() {
      *
      * @return This function promoted to return its value in a NonEmptyList.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public F1W<A, NonEmptyList<B>> nelK() {
         return lift(F1Functions.nelK(this));
     }
@@ -381,7 +381,7 @@ public F1W<A, Tree<B>> treeK() {
      *
      * @return This function promoted to map over a Tree.
      */
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public F1W<Tree<A>, Tree<B>> mapTree() {
         return lift(F1Functions.mapTree(this));
     }
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index c2214748..a85a4712 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -381,7 +381,7 @@ public static <A> Monoid<Stream<A>> streamMonoid() {
    *
    * @return A monoid for arrays.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public static <A> Monoid<Array<A>> arrayMonoid() {
     return monoid(Semigroup.<A>arraySemigroup(), Array.<A>empty());
   }
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index a6ed6c8f..c2983298 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -5,7 +5,7 @@
  *
  * @version %build.number%
  */
-@SuppressWarnings({"UnnecessaryFullyQualifiedName"})
+@SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P6<A, B, C, D, E, F> {
   /**
    * Access the first element of the product.
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index 76900fc4..478e3d87 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -5,7 +5,7 @@
  *
  * @version %build.number%
  */
-@SuppressWarnings({"UnnecessaryFullyQualifiedName"})
+@SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P7<A, B, C, D, E, F, G> {
   /**
    * Access the first element of the product.
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index d9e9f42c..62fef46e 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -5,7 +5,7 @@
  *
  * @version %build.number%
  */
-@SuppressWarnings({"UnnecessaryFullyQualifiedName"})
+@SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P8<A, B, C, D, E, F, G, H> {
   /**
    * Access the first element of the product.
diff --git a/core/src/main/java/fj/data/$.java b/core/src/main/java/fj/data/$.java
index 3ddf92d3..212216bc 100644
--- a/core/src/main/java/fj/data/$.java
+++ b/core/src/main/java/fj/data/$.java
@@ -6,7 +6,7 @@
  * The constant arrow, for attaching a new name to an existing type. For every pair of types A and B, this type
  * is the identity morphism from B to B.
  */
-@SuppressWarnings({"UnusedDeclaration"})
+@SuppressWarnings("UnusedDeclaration")
 public final class $<A, B> extends P1<B> {
 
   private final B b;
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index ea8c7312..f9ed8abb 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -202,7 +202,7 @@ public String toString() {
    * @param f The function to map across this array.
    * @return A new array after the given function has been applied to each element.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <B> Array<B> map(final F<A, B> f) {
     final Object[] bs = new Object[a.length];
 
@@ -323,7 +323,7 @@ public <B> B foldLeft(final F2<B, A, B> f, final B b) {
    * @param b The beginning value to start the application from.
    * @return The array containing all intermediate results of the left-fold reduction.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <B> Array<B> scanLeft(final F<B, F<A, B>> f, final B b) {
     final Object[] bs = new Object[a.length];
     B x = b;
@@ -357,7 +357,7 @@ public <B> Array<B> scanLeft(final F2<B, A, B> f, final B b) {
    * @param f The function to apply on each argument pair (next array element and first array element/previous result)
    * @return The array containing all intermediate results of the left-fold reduction.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public Array<A> scanLeft1(final F<A, F<A, A>> f) {
     final Object[] bs = new Object[a.length];
     A x = get(0);
@@ -392,7 +392,7 @@ public Array<A> scanLeft1(final F2<A, A, A> f) {
    * @param b The beginning value to start the application from.
    * @return The array containing all intermediate results of the right-fold reduction.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <B> Array<B> scanRight(final F<A, F<B, B>>f, final B b) {
     final Object[] bs = new Object[a.length];
     B x = b;
@@ -426,7 +426,7 @@ public <B> Array<B> scanRight(final F2<A, B, B> f, final B b) {
    * @param f The function to apply on each argument pair (previous array element and last array element/previous result)
    * @return The array containing all intermediate results of the right-fold reduction.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public Array<A> scanRight1(final F<A, F<A, A>>f) {
     final Object[] bs = new Object[a.length];
     A x = get(length() - 1);
@@ -459,7 +459,7 @@ public Array<A> scanRight1(final F2<A, A, A> f) {
    * @param f The function to apply to each element of this array.
    * @return A new array after performing the map, then final join.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <B> Array<B> bind(final F<A, Array<B>> f) {
     List<Array<B>> x = List.nil();
     int len = 0;
@@ -849,7 +849,7 @@ public static <A> Array<A> arrayArray(final A...as) {
    * @param xs The array of pairs to transform.
    * @return An array of first components and an array of second components.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public static <A, B> P2<Array<A>, Array<B>> unzip(final Array<P2<A, B>> xs) {
     final int len = xs.length();
     final Array<A> aa = new Array<A>(new Object[len]);
@@ -1079,7 +1079,7 @@ public static <T, U> T[] copyOf(final U[] a, final int len, final Class<? extend
     return copy;
   }
 
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public static <T> T[] copyOf(final T[] a, final int len) {
       return (T[]) copyOf(a, len, a.getClass());
   }
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index 7cd9c8dd..3e6ff3b3 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -32,7 +32,7 @@ K k() {
       return k;
     }
 
-    @SuppressWarnings({"unchecked"})
+    @SuppressWarnings("unchecked")
     public boolean equals(final Object o) {
       return o instanceof Key && e.eq(k, (K) ((Key<?>) o).k());
     }
diff --git a/core/src/main/java/fj/data/IterableW.java b/core/src/main/java/fj/data/IterableW.java
index 52be7d6b..523b4152 100644
--- a/core/src/main/java/fj/data/IterableW.java
+++ b/core/src/main/java/fj/data/IterableW.java
@@ -324,7 +324,7 @@ public boolean isEmpty() {
         return iterableStream(IterableW.this).isEmpty();
       }
 
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public boolean contains(final Object o) {
         return iterableStream(IterableW.this).exists(Equal.<A>anyEqual().eq((A) o));
       }
@@ -337,7 +337,7 @@ public Object[] toArray() {
         return Array.iterableArray(iterableStream(IterableW.this)).array();
       }
 
-      @SuppressWarnings({"SuspiciousToArrayCall"})
+      @SuppressWarnings("SuspiciousToArrayCall")
       public <T> T[] toArray(final T[] a) {
         return iterableStream(IterableW.this).toCollection().toArray(a);
       }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 4920e021..26ec5e33 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -195,7 +195,7 @@ public final Stream<A> toStream() {
    *
    * @return A array projection of this list.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final Array<A> toArray() {
     return mkArray(toArrayObject());
   }
@@ -1124,7 +1124,7 @@ public final List<A> intersperse(final A a) {
    * @param as The list to intersperse through.
    * @return This list through the given list then joins the results.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final List<A> intercalate(final List<List<A>> as) {
     return join(as.intersperse(this));
   }
@@ -1154,7 +1154,7 @@ public final List<A> nub(final Equal<A> eq) {
    * @param o An ordering for the elements.
    * @return A list without duplicates.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final List<A> nub(final Ord<A> o) {
     return sort(o).group(o.equal()).map(List.<A>head_());
   }
@@ -2044,7 +2044,7 @@ public static <A> Buffer<A> iterableBuffer(final Iterable<A> i) {
       return b;
     }
 
-    @SuppressWarnings({"ObjectEquality"})
+    @SuppressWarnings("ObjectEquality")
     private void copy() {
       List<A> s = start;
       final Cons<A> t = tail;
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 476d38db..cb58e61f 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -542,7 +542,7 @@ public final Stream<A> toStream() {
    *
    * @return An array projection of this optional value.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final Array<A> toArray() {
     return isSome() ? Array.array(some()) : Array.<A>empty();
   }
@@ -553,7 +553,7 @@ public final Array<A> toArray() {
    * @param c The class type of the array to return.
    * @return An array projection of this optional value.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final Array<A> toArray(final Class<A[]> c) {
     if (isSome()) {
       final A[] a = (A[]) java.lang.reflect.Array.newInstance(c.getComponentType(), 1);
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 6c23d6d5..09d80279 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -31,7 +31,7 @@ public final boolean isEmpty() {
     return this instanceof Empty;
   }
 
-  @SuppressWarnings({"ClassEscapesDefinedScope"})
+  @SuppressWarnings("ClassEscapesDefinedScope")
   abstract Color color();
 
   abstract Set<A> l();
@@ -209,7 +209,7 @@ private Set<A> makeBlack() {
     return new Tree<A>(ord, Color.B, l(), head(), r());
   }
 
-  @SuppressWarnings({"SuspiciousNameCombination"})
+  @SuppressWarnings("SuspiciousNameCombination")
   private static <A> Tree<A> tr(final Ord<A> o,
                                 final Set<A> a, final A x, final Set<A> b,
                                 final A y,
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 2e7ca879..cb6fe8d0 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -957,7 +957,7 @@ public final java.util.List<A> toJavaList() {
    *
    * @return A array projection of this stream.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public final Array<A> toArray() {
     final int l = length();
     final Object[] a = new Object[l];
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index 307c279e..e35e6592 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -358,7 +358,7 @@ public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
    * @param f A function to apply to the values of this TreeMap.
    * @return A new TreeMap with the values transformed by the given function.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <W> TreeMap<K, W> map(final F<V, W> f) {
     final F<P2<K, Option<V>>, P2<K, Option<W>>> g = P2.map2_(F1Functions.mapOption(f));
     final F<K, P2<K, Option<V>>> coord = flip(P.<K, Option<V>>p2()).f(Option.<V>none());
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 3a2cfa23..a87b4585 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -172,7 +172,7 @@ public void foreachDoEffect(final Effect1<T> f) {
    * @param f The function to map.
    * @return A new validation with the function mapped.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <A> Validation<E, A> map(final F<T, A> f) {
     return isFail() ?
         Validation.<E, A>fail(fail()) :
@@ -185,7 +185,7 @@ public <A> Validation<E, A> map(final F<T, A> f) {
    * @param f The function to bind across this validation.
    * @return A new validation value after binding.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
     return isSuccess() ? f.f(success()) : Validation.<E, A>fail(fail());
   }
@@ -313,7 +313,7 @@ public Stream<T> toStream() {
    * @return A failing validation if this or the given validation failed (with errors accumulated if both) or a
    *         succeeding validation if both succeeded.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public <A> Validation<E, A> accumapply(final Semigroup<E> s, final Validation<E, F<T, A>> v) {
     return isFail() ?
         Validation.<E, A>fail(v.isFail() ?
@@ -1080,7 +1080,7 @@ public Iterator<E> iterator() {
    *
    * @return A validation with its failing value in a non-empty list if there is one.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public Validation<NonEmptyList<E>, T> nel() {
     return isSuccess() ?
         Validation.<NonEmptyList<E>, T>success(success()) :
diff --git a/core/src/main/java/fj/data/Zipper.java b/core/src/main/java/fj/data/Zipper.java
index a4377507..6de0d39c 100644
--- a/core/src/main/java/fj/data/Zipper.java
+++ b/core/src/main/java/fj/data/Zipper.java
@@ -169,7 +169,7 @@ public static <A> Zipper<A> single(final A a) {
    * @param a The stream from which to create a zipper.
    * @return a new zipper if the provided stream has at least one element, otherwise None.
    */
-  @SuppressWarnings({"IfMayBeConditional"})
+  @SuppressWarnings("IfMayBeConditional")
   public static <A> Option<Zipper<A>> fromStream(final Stream<A> a) {
     if (a.isEmpty())
       return none();
diff --git a/demo/src/main/java/fj/demo/concurrent/PingPong.java b/demo/src/main/java/fj/demo/concurrent/PingPong.java
index 59038679..d6bddbbf 100644
--- a/demo/src/main/java/fj/demo/concurrent/PingPong.java
+++ b/demo/src/main/java/fj/demo/concurrent/PingPong.java
@@ -16,7 +16,7 @@
  * Example of parallel synchronous messaging using Actors in Functional Java.
  * Author: Runar
  */
-@SuppressWarnings({"ArithmeticOnVolatileField"})
+@SuppressWarnings("ArithmeticOnVolatileField")
 public class PingPong {
   private final int actors;
   private final int pings;
diff --git a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
index b2c230a5..e0c99f64 100644
--- a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
+++ b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
@@ -39,7 +39,7 @@ For any list, mapping the identity function (\x -> x) produces the same list.
 
 Note that to test this second law requires the generation of arbitrary functions.
 */
-@SuppressWarnings({"PackageVisibleField"})
+@SuppressWarnings("PackageVisibleField")
 @CheckParams(minSuccessful = 1000)
 public final class ListFunctorLaws {
   final Property identity = property(arbList(arbString), x -> prop(listEqual(stringEqual).eq(x, x.map(Function.<String>identity()))));
diff --git a/demo/src/main/java/fj/demo/test/Reflect.java b/demo/src/main/java/fj/demo/test/Reflect.java
index 8831314e..79d013dc 100644
--- a/demo/src/main/java/fj/demo/test/Reflect.java
+++ b/demo/src/main/java/fj/demo/test/Reflect.java
@@ -82,7 +82,7 @@ Property leave() {
     throw error("this should not be executed");
   }
 
-  @SuppressWarnings({"UnusedDeclaration"})
+  @SuppressWarnings("UnusedDeclaration")
   Property leave(final int i) {
     throw error("this should not be executed");
   }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index d46f4d4e..34a17ae1 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -95,7 +95,7 @@ public final class Arbitrary<A> {
   /**
    * The generator associated with this arbitrary.
    */
-  @SuppressWarnings({"PublicField"})
+  @SuppressWarnings("PublicField")
   public final Gen<A> gen;
 
   private Arbitrary(final Gen<A> gen) {
@@ -668,7 +668,7 @@ public StringBuilder f(final String s) {
    */
   public static <A> Arbitrary<Gen<A>> arbGen(final Arbitrary<A> aa) {
     return arbitrary(sized(new F<Integer, Gen<Gen<A>>>() {
-      @SuppressWarnings({"IfMayBeConditional"})
+      @SuppressWarnings("IfMayBeConditional")
       public Gen<Gen<A>> f(final Integer i) {
         if (i == 0)
           return fail();
@@ -711,7 +711,7 @@ public Option<A> f(final A a) {
    *           defined.
    * @return An arbitrary implementation for the disjoint union.
    */
-  @SuppressWarnings({"unchecked"})
+  @SuppressWarnings("unchecked")
   public static <A, B> Arbitrary<Either<A, B>> arbEither(final Arbitrary<A> aa, final Arbitrary<B> ab) {
     final Gen<Either<A, B>> left = aa.gen.map(new F<A, Either<A, B>>() {
       public Either<A, B> f(final A a) {
@@ -916,7 +916,7 @@ public static <A extends Enum<A>> Arbitrary<A> arbEnumValue(final Class<A> clazz
   public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final Arbitrary<K> ak,
                                                                            final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, EnumMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public EnumMap<K, V> f(final Hashtable<K, V> ht) {
         return new EnumMap<K, V>(ht);
       }
@@ -959,7 +959,7 @@ public GregorianCalendar f(final Long i) {
    */
   public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, HashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public HashMap<K, V> f(final Hashtable<K, V> ht) {
         return new HashMap<K, V>(ht);
       }
@@ -993,7 +993,7 @@ public static <K, V> Arbitrary<Hashtable<K, V>> arbHashtable(final Arbitrary<K>
     return arbitrary(arbList(ak).gen.bind(arbList(av).gen, new F<List<K>, F<List<V>, Hashtable<K, V>>>() {
       public F<List<V>, Hashtable<K, V>> f(final List<K> ks) {
         return new F<List<V>, Hashtable<K, V>>() {
-          @SuppressWarnings({"UseOfObsoleteCollectionType"})
+          @SuppressWarnings("UseOfObsoleteCollectionType")
           public Hashtable<K, V> f(final List<V> vs) {
             final Hashtable<K, V> t = new Hashtable<K, V>();
 
@@ -1022,7 +1022,7 @@ public void f(final P2<K, V> kv) {
   public static <K, V> Arbitrary<IdentityHashMap<K, V>> arbIdentityHashMap(final Arbitrary<K> ak,
                                                                            final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, IdentityHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public IdentityHashMap<K, V> f(final Hashtable<K, V> ht) {
         return new IdentityHashMap<K, V>(ht);
       }
@@ -1040,7 +1040,7 @@ public IdentityHashMap<K, V> f(final Hashtable<K, V> ht) {
    */
   public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, LinkedHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public LinkedHashMap<K, V> f(final Hashtable<K, V> ht) {
         return new LinkedHashMap<K, V>(ht);
       }
@@ -1094,7 +1094,7 @@ public PriorityQueue<A> f(final Array<A> a) {
    */
   public static final Arbitrary<Properties> arbProperties =
       arbitrary(arbHashtable(arbString, arbString).gen.map(new F<Hashtable<String, String>, Properties>() {
-        @SuppressWarnings({"UseOfObsoleteCollectionType"})
+        @SuppressWarnings("UseOfObsoleteCollectionType")
         public Properties f(final Hashtable<String, String> ht) {
           final Properties p = new Properties();
 
@@ -1132,7 +1132,7 @@ public Stack<A> f(final Array<A> a) {
    */
   public static <K, V> Arbitrary<java.util.TreeMap<K, V>> arbJavaTreeMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, java.util.TreeMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public java.util.TreeMap<K, V> f(final Hashtable<K, V> ht) {
         return new java.util.TreeMap<K, V>(ht);
       }
@@ -1196,10 +1196,10 @@ public TreeSet<A> f(final Array<A> a) {
    * @param aa An arbitrary implementation for the type over which the vector is defined.
    * @return An arbitrary implementation for vectors.
    */
-  @SuppressWarnings({"UseOfObsoleteCollectionType"})
+  @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.map(new F<Array<A>, Vector<A>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public Vector<A> f(final Array<A> a) {
         return new Vector<A>(a.toCollection());
       }
@@ -1217,7 +1217,7 @@ public Vector<A> f(final Array<A> a) {
    */
   public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, WeakHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public WeakHashMap<K, V> f(final Hashtable<K, V> ht) {
         return new WeakHashMap<K, V>(ht);
       }
@@ -1265,7 +1265,7 @@ public ArrayBlockingQueue<A> f(final Boolean fair) {
   public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(final Arbitrary<K> ak,
                                                                                final Arbitrary<V> av) {
     return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, ConcurrentHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public ConcurrentHashMap<K, V> f(final Hashtable<K, V> ht) {
         return new ConcurrentHashMap<K, V>(ht);
       }
diff --git a/quickcheck/src/main/java/fj/test/CheckResult.java b/quickcheck/src/main/java/fj/test/CheckResult.java
index fe3ca92a..dc0195d7 100644
--- a/quickcheck/src/main/java/fj/test/CheckResult.java
+++ b/quickcheck/src/main/java/fj/test/CheckResult.java
@@ -236,7 +236,7 @@ private String arguments(final CheckResult r) {
         return args.length() == 1 ? "argument: " + sa.showS(args.head()) : "arguments: " + listShow(sa).showS(args);
       }
 
-      @SuppressWarnings({"ThrowableResultOfMethodCallIgnored"})
+      @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
       public String f(final CheckResult r) {
         if (r.isProven())
           return "OK, property proven with " + arguments(r);
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index 8b778188..bb607aa5 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -530,7 +530,7 @@ public String f(final Throwable t) {
    */
   public static <A> Coarbitrary<ArrayList<A>> coarbArrayList(final Coarbitrary<A> ca) {
     return new Coarbitrary<ArrayList<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ArrayList<A> as, final Gen<B> g) {
         return coarbArray(ca).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -580,7 +580,7 @@ public <B> Gen<B> coarbitrary(final Date d, final Gen<B> g) {
   public static <K extends Enum<K>, V> Coarbitrary<EnumMap<K, V>> coarbEnumMap(final Coarbitrary<K> ck,
                                                                                final Coarbitrary<V> cv) {
     return new Coarbitrary<EnumMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final EnumMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -595,7 +595,7 @@ public <B> Gen<B> coarbitrary(final EnumMap<K, V> m, final Gen<B> g) {
    */
   public static <A extends Enum<A>> Coarbitrary<EnumSet<A>> coarbEnumSet(final Coarbitrary<A> c) {
     return new Coarbitrary<EnumSet<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final EnumSet<A> as, final Gen<B> g) {
         return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
       }
@@ -620,7 +620,7 @@ public <B> Gen<B> coarbitrary(final GregorianCalendar c, final Gen<B> g) {
    */
   public static <K, V> Coarbitrary<HashMap<K, V>> coarbHashMap(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
     return new Coarbitrary<HashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final HashMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -635,7 +635,7 @@ public <B> Gen<B> coarbitrary(final HashMap<K, V> m, final Gen<B> g) {
    */
   public static <A> Coarbitrary<HashSet<A>> coarbHashSet(final Coarbitrary<A> c) {
     return new Coarbitrary<HashSet<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final HashSet<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -651,7 +651,7 @@ public <B> Gen<B> coarbitrary(final HashSet<A> as, final Gen<B> g) {
    */
   public static <K, V> Coarbitrary<Hashtable<K, V>> coarbHashtable(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
     return new Coarbitrary<Hashtable<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final Hashtable<K, V> h, final Gen<B> g) {
         List<P2<K, V>> x = nil();
 
@@ -674,7 +674,7 @@ public <B> Gen<B> coarbitrary(final Hashtable<K, V> h, final Gen<B> g) {
   public static <K, V> Coarbitrary<IdentityHashMap<K, V>> coarbIdentityHashMap(final Coarbitrary<K> ck,
                                                                                final Coarbitrary<V> cv) {
     return new Coarbitrary<IdentityHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final IdentityHashMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -691,7 +691,7 @@ public <B> Gen<B> coarbitrary(final IdentityHashMap<K, V> m, final Gen<B> g) {
   public static <K, V> Coarbitrary<LinkedHashMap<K, V>> coarbLinkedHashMap(final Coarbitrary<K> ck,
                                                                            final Coarbitrary<V> cv) {
     return new Coarbitrary<LinkedHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final LinkedHashMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -706,7 +706,7 @@ public <B> Gen<B> coarbitrary(final LinkedHashMap<K, V> m, final Gen<B> g) {
    */
   public static <A> Coarbitrary<LinkedHashSet<A>> coarbLinkedHashSet(final Coarbitrary<A> c) {
     return new Coarbitrary<LinkedHashSet<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedHashSet<A> as, final Gen<B> g) {
         return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
       }
@@ -721,7 +721,7 @@ public <B> Gen<B> coarbitrary(final LinkedHashSet<A> as, final Gen<B> g) {
    */
   public static <A> Coarbitrary<LinkedList<A>> coarbLinkedList(final Coarbitrary<A> c) {
     return new Coarbitrary<LinkedList<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedList<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -736,7 +736,7 @@ public <B> Gen<B> coarbitrary(final LinkedList<A> as, final Gen<B> g) {
    */
   public static <A> Coarbitrary<PriorityQueue<A>> coarbPriorityQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<PriorityQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final PriorityQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -747,7 +747,7 @@ public <B> Gen<B> coarbitrary(final PriorityQueue<A> as, final Gen<B> g) {
    * A coarbitrary for properties.
    */
   public static final Coarbitrary<Properties> coarbProperties = new Coarbitrary<Properties>() {
-    @SuppressWarnings({"UseOfObsoleteCollectionType"})
+    @SuppressWarnings("UseOfObsoleteCollectionType")
     public <B> Gen<B> coarbitrary(final Properties p, final Gen<B> g) {
       final Hashtable<String, String> t = new Hashtable<String, String>();
 
@@ -767,7 +767,7 @@ public <B> Gen<B> coarbitrary(final Properties p, final Gen<B> g) {
    */
   public static <A> Coarbitrary<Stack<A>> coarbStack(final Coarbitrary<A> c) {
     return new Coarbitrary<Stack<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final Stack<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -783,7 +783,7 @@ public <B> Gen<B> coarbitrary(final Stack<A> as, final Gen<B> g) {
    */
   public static <K, V> Coarbitrary<TreeMap<K, V>> coarbTreeMap(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
     return new Coarbitrary<TreeMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final TreeMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -798,7 +798,7 @@ public <B> Gen<B> coarbitrary(final TreeMap<K, V> m, final Gen<B> g) {
    */
   public static <A> Coarbitrary<TreeSet<A>> coarbTreeSet(final Coarbitrary<A> c) {
     return new Coarbitrary<TreeSet<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final TreeSet<A> as, final Gen<B> g) {
         return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
       }
@@ -830,7 +830,7 @@ public <B> Gen<B> coarbitrary(final Vector<A> as, final Gen<B> g) {
   public static <K, V> Coarbitrary<WeakHashMap<K, V>> coarbWeakHashMap(final Coarbitrary<K> ck,
                                                                        final Coarbitrary<V> cv) {
     return new Coarbitrary<WeakHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final WeakHashMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -849,7 +849,7 @@ public <B> Gen<B> coarbitrary(final WeakHashMap<K, V> m, final Gen<B> g) {
    */
   public static <A> Coarbitrary<ArrayBlockingQueue<A>> coarbArrayBlockingQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<ArrayBlockingQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ArrayBlockingQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -866,7 +866,7 @@ public <B> Gen<B> coarbitrary(final ArrayBlockingQueue<A> as, final Gen<B> g) {
   public static <K, V> Coarbitrary<ConcurrentHashMap<K, V>> coarbConcurrentHashMap(final Coarbitrary<K> ck,
                                                                                    final Coarbitrary<V> cv) {
     return new Coarbitrary<ConcurrentHashMap<K, V>>() {
-      @SuppressWarnings({"UseOfObsoleteCollectionType"})
+      @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final ConcurrentHashMap<K, V> m, final Gen<B> g) {
         return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
       }
@@ -881,7 +881,7 @@ public <B> Gen<B> coarbitrary(final ConcurrentHashMap<K, V> m, final Gen<B> g) {
    */
   public static <A> Coarbitrary<ConcurrentLinkedQueue<A>> coarbConcurrentLinkedQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<ConcurrentLinkedQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ConcurrentLinkedQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -896,7 +896,7 @@ public <B> Gen<B> coarbitrary(final ConcurrentLinkedQueue<A> as, final Gen<B> g)
    */
   public static <A> Coarbitrary<CopyOnWriteArrayList<A>> coarbCopyOnWriteArrayList(final Coarbitrary<A> c) {
     return new Coarbitrary<CopyOnWriteArrayList<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final CopyOnWriteArrayList<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -911,7 +911,7 @@ public <B> Gen<B> coarbitrary(final CopyOnWriteArrayList<A> as, final Gen<B> g)
    */
   public static <A> Coarbitrary<CopyOnWriteArraySet<A>> coarbCopyOnWriteArraySet(final Coarbitrary<A> c) {
     return new Coarbitrary<CopyOnWriteArraySet<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final CopyOnWriteArraySet<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -926,7 +926,7 @@ public <B> Gen<B> coarbitrary(final CopyOnWriteArraySet<A> as, final Gen<B> g) {
    */
   public static <A extends Delayed> Coarbitrary<DelayQueue<A>> coarbDelayQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<DelayQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final DelayQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -941,7 +941,7 @@ public <B> Gen<B> coarbitrary(final DelayQueue<A> as, final Gen<B> g) {
    */
   public static <A> Coarbitrary<LinkedBlockingQueue<A>> coarbLinkedBlockingQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<LinkedBlockingQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedBlockingQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -956,7 +956,7 @@ public <B> Gen<B> coarbitrary(final LinkedBlockingQueue<A> as, final Gen<B> g) {
    */
   public static <A> Coarbitrary<PriorityBlockingQueue<A>> coarbPriorityBlockingQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<PriorityBlockingQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final PriorityBlockingQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
@@ -971,7 +971,7 @@ public <B> Gen<B> coarbitrary(final PriorityBlockingQueue<A> as, final Gen<B> g)
    */
   public static <A> Coarbitrary<SynchronousQueue<A>> coarbSynchronousQueue(final Coarbitrary<A> c) {
     return new Coarbitrary<SynchronousQueue<A>>() {
-      @SuppressWarnings({"unchecked"})
+      @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final SynchronousQueue<A> as, final Gen<B> g) {
         return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
       }
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 18baccc3..3231cf2e 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -133,7 +133,7 @@ public Result f(final Result res2) {
    * @param maxSize       The maximum size to use for checking.
    * @return A result after checking this property.
    */
-  @SuppressWarnings({"ThrowableResultOfMethodCallIgnored"})
+  @SuppressWarnings("ThrowableResultOfMethodCallIgnored")
   public CheckResult check(final Rand r,
                            final int minSuccessful,
                            final int maxDiscarded,
@@ -453,7 +453,7 @@ public F<Rand, Result> f(final Integer i) {
         return new F<Rand, Result>() {
           public Result f(final Rand r) {
             final class Util {
-              @SuppressWarnings({"IfMayBeConditional"})
+              @SuppressWarnings("IfMayBeConditional")
               Option<P2<A, Result>> first(final Stream<A> as, final int shrinks) {
                 final Stream<Option<P2<A, Result>>> results = as.map(new F<A, Option<P2<A, Result>>>() {
                   public Option<P2<A, Result>> f(final A a) {
diff --git a/quickcheck/src/main/java/fj/test/Result.java b/quickcheck/src/main/java/fj/test/Result.java
index 40a388d6..eb6b973b 100644
--- a/quickcheck/src/main/java/fj/test/Result.java
+++ b/quickcheck/src/main/java/fj/test/Result.java
@@ -142,7 +142,7 @@ public Result addArg(final Arg<?> a) {
    *
    * @return A potential result for this result.
    */
-  @SuppressWarnings({"IfMayBeConditional"})
+  @SuppressWarnings("IfMayBeConditional")
   public Option<Result> toOption() {
     if(isNoResult())
       return none();
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index d1403ee7..a9d1aa21 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -241,7 +241,7 @@ else if (as.tail().isEmpty())
         }
       }
 
-      @SuppressWarnings({"IfMayBeConditional"})
+      @SuppressWarnings("IfMayBeConditional")
       Stream<List<A>> shrinkOne(final List<A> as) {
         if (as.isEmpty())
           return nil();
@@ -402,7 +402,7 @@ public static <A> Shrink<HashSet<A>> shrinkHashSet(final Shrink<A> sa) {
    * @param sv The shrink stratgey for values.
    * @return A shrink strategy for hash tables.
    */
-  @SuppressWarnings({"UseOfObsoleteCollectionType"})
+  @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <K, V> Shrink<Hashtable<K, V>> shrinkHashtable(final Shrink<K> sk, final Shrink<V> sv) {
     return shrinkList(shrinkP2(sk, sv)).map(kvs -> {
       final Hashtable<K, V> h = new Hashtable<K, V>();
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index 199f399a..079dcb22 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -260,14 +260,14 @@ private interface PropertyMember {
     AnnotatedElement element();
     String name();
     int modifiers();
-    @SuppressWarnings({"ProhibitedExceptionDeclared"})
+    @SuppressWarnings("ProhibitedExceptionDeclared")
     <X> Property invoke(X x) throws Exception;
     boolean isProperty();
   }
 
   private static <T> Array<P3<Property, String, Option<CheckParams>>> properties(final Array<PropertyMember> ms, final java.lang.Class<T> declaringClass, final String... categories) {
     final Option<T> t = emptyCtor(declaringClass).map(new F<Constructor<T>, T>() {
-      @SuppressWarnings({"OverlyBroadCatchBlock"})
+      @SuppressWarnings("OverlyBroadCatchBlock")
       public T f(final Constructor<T> ctor) {
         try {
           ctor.setAccessible(true);

From 673bfd6dc27f86dd9a8b764e70cf07cc6e8312ee Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 18:31:53 +0100
Subject: [PATCH 030/336] Fix non-sense in List_map demo

---
 demo/src/main/java/fj/demo/List_map.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/demo/src/main/java/fj/demo/List_map.java b/demo/src/main/java/fj/demo/List_map.java
index 55216810..a07f0015 100644
--- a/demo/src/main/java/fj/demo/List_map.java
+++ b/demo/src/main/java/fj/demo/List_map.java
@@ -9,8 +9,8 @@
 public final class List_map {
     public static void main(final String[] args) {
         final List<Integer> a = list(1, 2, 3);
-        final List<Integer> b = a.map(add.f(42));
-        final List<Integer> c = a.map(i -> i = 42);
+        final List<Integer> b = a.map(add.f(42)); // or equivalently:
+        final List<Integer> c = a.map(i -> i + 42);
         listShow(intShow).println(b); // [43,44,45]
     }
 }

From df48c32bf6ab51b8cef3f16ad4fe89ed756edb46 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 18:38:26 +0100
Subject: [PATCH 031/336] Use e.printStackTrace() instead of println(e)

---
 quickcheck/src/main/java/fj/test/reflect/Main.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/quickcheck/src/main/java/fj/test/reflect/Main.java b/quickcheck/src/main/java/fj/test/reflect/Main.java
index a7e8be3c..b0b5fb95 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Main.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Main.java
@@ -43,7 +43,7 @@ public void f(final P2<String, CheckResult> r) {
             }
         });
       } catch(ClassNotFoundException e) {
-        System.err.println(e);
+        e.printStackTrace();
         //noinspection CallToSystemExit
         exit(144);
       }

From 2a27fa8203b241df29b8955e7d13916add709f4a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 19:47:50 +0100
Subject: [PATCH 032/336] Remove unnecessary qualification of static methods

---
 core/src/main/java/fj/Equal.java              |  2 +-
 core/src/main/java/fj/F1Functions.java        |  2 +-
 core/src/main/java/fj/Function.java           |  2 +-
 core/src/main/java/fj/Hash.java               |  2 +-
 core/src/main/java/fj/P.java                  |  4 +-
 core/src/main/java/fj/Show.java               |  6 +--
 core/src/main/java/fj/Try.java                |  2 +-
 .../java/fj/control/parallel/Callables.java   |  2 +-
 .../java/fj/control/parallel/Promise.java     | 14 +++---
 core/src/main/java/fj/data/Array.java         | 10 ++--
 core/src/main/java/fj/data/Conversions.java   |  2 +-
 core/src/main/java/fj/data/DList.java         |  4 +-
 core/src/main/java/fj/data/Either.java        | 12 ++---
 core/src/main/java/fj/data/Enumerator.java    |  4 +-
 core/src/main/java/fj/data/HashMap.java       |  2 +-
 core/src/main/java/fj/data/IOFunctions.java   | 14 +++---
 core/src/main/java/fj/data/IOW.java           |  2 +-
 core/src/main/java/fj/data/IterableW.java     |  2 +-
 core/src/main/java/fj/data/LazyString.java    |  2 +-
 core/src/main/java/fj/data/List.java          | 44 +++++++++---------
 core/src/main/java/fj/data/Option.java        |  2 +-
 core/src/main/java/fj/data/Seq.java           |  2 +-
 core/src/main/java/fj/data/State.java         |  2 +-
 core/src/main/java/fj/data/Stream.java        | 24 +++++-----
 core/src/main/java/fj/data/Tree.java          |  4 +-
 core/src/main/java/fj/data/TreeMap.java       | 18 ++++----
 core/src/main/java/fj/data/Validation.java    | 46 +++++++++----------
 core/src/main/java/fj/data/Writer.java        |  2 +-
 .../java/fj/data/fingertrees/FingerTree.java  |  2 +-
 .../main/java/fj/data/fingertrees/Single.java |  2 +-
 .../main/java/fj/demo/realworld/Chapter7.java |  2 +-
 .../src/main/java/fj/test/Arbitrary.java      | 10 ++--
 .../src/main/java/fj/test/Property.java       |  4 +-
 33 files changed, 127 insertions(+), 127 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 23ceffd3..27973afc 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -538,7 +538,7 @@ public static <A> Equal<Set<A>> setEqual(final Equal<A> e) {
   }
 
   public static <K, V> Equal<TreeMap<K, V>> treeMapEqual(Equal<K> k, Equal<V> v) {
-    return equal(t1 -> t2 -> Equal.streamEqual(p2Equal(k, v)).eq(t1.toStream(), t2.toStream()));
+    return equal(t1 -> t2 -> streamEqual(p2Equal(k, v)).eq(t1.toStream(), t2.toStream()));
   }
 
   public static <A, B> Equal<Writer<A, B>> writerEqual(Equal<A> eq1, Equal<B> eq2) {
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 12f565b2..3faf1b5e 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -330,7 +330,7 @@ public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
      */
     @SuppressWarnings("unchecked")
     public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
-        return F1Functions.o(IterableW.<A, B>map().f(f), IterableW.<A, Iterable<A>>wrap());
+        return o(IterableW.<A, B>map().f(f), IterableW.<A, Iterable<A>>wrap());
     }
 
     /**
diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index 4d4b14a2..b3b96870 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -60,7 +60,7 @@ public static <A, B, C, D> F<A, F<B, D>> compose2(final F<C, D> f, final F<A, F<
    * @return A function that composes two functions to produce a new function.
    */
   public static <A, B, C> F<F<A, B>, F<F<B, C>, F<A, C>>> andThen() {
-    return g -> f -> Function.andThen(g, f);
+    return g -> f -> andThen(g, f);
   }
 
   /**
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 26f42049..61c5e1cd 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -268,7 +268,7 @@ public static <A> Hash<Tree<A>> treeHash(final Hash<A> ha) {
   }
 
     public static <K, V> Hash<TreeMap<K, V>> treeMapHash(final Hash<K> h, final Hash<V> v) {
-        return hash(t -> streamHash(Hash.p2Hash(h, v)).hash(t.toStream()));
+        return hash(t -> streamHash(p2Hash(h, v)).hash(t.toStream()));
     }
 
   /**
diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index 073de4f6..2826b6b0 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -234,7 +234,7 @@ public H _8() {
     }
 
     public static <A, B> P2<A, B> lazyProduct(F0<P2<A, B>> f) {
-        return P.lazy(() -> f.f()._1(), () -> f.f()._2());
+        return lazy(() -> f.f()._1(), () -> f.f()._2());
     }
 
     /**
@@ -552,7 +552,7 @@ public static <A> P1<A> lazy(F<Unit, A> f) {
     }
 
     public static <A, B> P2<A, B> lazy(F<Unit, A> fa, F<Unit, B> fb) {
-        return P.lazy(() -> fa.f(unit()), () -> fb.f(unit()));
+        return lazy(() -> fa.f(unit()), () -> fb.f(unit()));
     }
 
     public static <A, B, C> P3<A, B, C> lazy(F<Unit, A> fa, F<Unit, B> fb, F<Unit, C> fc) {
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index b67f662a..7e832c6c 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -159,7 +159,7 @@ public static <A> Show<A> showS(final F<A, String> f) {
    * @return A show instance that uses {@link Object#toString()} to perform the display rendering.
    */
   public static <A> Show<A> anyShow() {
-    return show(a -> Stream.fromString((a == null) ? "null" : a.toString()));
+    return show(a -> fromString((a == null) ? "null" : a.toString()));
   }
 
   /**
@@ -325,7 +325,7 @@ public static <A> Show<Set<A>> setShow(final Show<A> sa) {
   public static <K, V> Show<TreeMap<K, V>> treeMapShow(final Show<K> sk, final Show<V> sv) {
     return show(tm -> {
       Stream<P2<K, V>> stream = Stream.iteratorStream(tm.iterator());
-      return streamShow(Show.p2MapShow(sk, sv), "TreeMap(", ",", ")").show(stream);
+      return streamShow(p2MapShow(sk, sv), "TreeMap(", ",", ")").show(stream);
     });
   }
 
@@ -425,7 +425,7 @@ public static <A> Show<P1<A>> p1Show(final Show<A> sa) {
   }
 
   public static <A> Show<P1<A>> p1ShowLazy(final Show<A> sa) {
-    return show(p -> Stream.fromString("(?)"));
+    return show(p -> fromString("(?)"));
   }
 
   public static <A> Show<P1<A>> p1ShowEager(final Show<A> sa) {
diff --git a/core/src/main/java/fj/Try.java b/core/src/main/java/fj/Try.java
index d18d7dbd..d8a30130 100644
--- a/core/src/main/java/fj/Try.java
+++ b/core/src/main/java/fj/Try.java
@@ -45,7 +45,7 @@ public static <A, E extends Exception> P1<Validation<E, A>> f(final Try0<A, E> t
     public static <A, B, E extends Exception> F<A, Validation<E, B>> f(final Try1<A, B, E> t) {
         return a -> {
             try {
-                return Validation.success(t.f(a));
+                return success(t.f(a));
             } catch (Exception e) {
                 return fail((E) e);
             }
diff --git a/core/src/main/java/fj/control/parallel/Callables.java b/core/src/main/java/fj/control/parallel/Callables.java
index 1b6114fe..aeb9a312 100644
--- a/core/src/main/java/fj/control/parallel/Callables.java
+++ b/core/src/main/java/fj/control/parallel/Callables.java
@@ -93,7 +93,7 @@ public static <A, B> Callable<B> bind(final Callable<A> a, final F<A, Callable<B
    * @return That function lifted to a function on Callables.
    */
   public static <A, B> F<Callable<A>, Callable<B>> fmap(final F<A, B> f) {
-    return a -> Callables.bind(a, callable(f));
+    return a -> bind(a, callable(f));
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Promise.java b/core/src/main/java/fj/control/parallel/Promise.java
index 100b50f6..42f9e3c2 100644
--- a/core/src/main/java/fj/control/parallel/Promise.java
+++ b/core/src/main/java/fj/control/parallel/Promise.java
@@ -75,7 +75,7 @@ public void f(final P2<Either<P1<A>, Actor<A>>, Promise<A>> p) {
    */
   public static <A> Promise<A> promise(final Strategy<Unit> s, final P1<A> a) {
     final Promise<A> p = mkPromise(s);
-    p.actor.act(P.p(Either.<P1<A>, Actor<A>>left(a), p));
+    p.actor.act(p(Either.<P1<A>, Actor<A>>left(a), p));
     return p;
   }
 
@@ -118,7 +118,7 @@ public static <A, B> F<A, Promise<B>> promise(final Strategy<Unit> s, final F<A,
    * @param a An actor that will receive this Promise's value in the future.
    */
   public void to(final Actor<A> a) {
-    actor.act(P.p(Either.<P1<A>, Actor<A>>right(a), this));
+    actor.act(p(Either.<P1<A>, Actor<A>>right(a), this));
   }
 
   /**
@@ -176,7 +176,7 @@ public <B> Promise<B> bind(final F<A, Promise<B>> f) {
     final Promise<B> r = mkPromise(s);
     final Actor<B> ab = actor(s, new Effect1<B>() {
       public void f(final B b) {
-        r.actor.act(P.p(Either.<P1<B>, Actor<B>>left(P.p(b)), r));
+        r.actor.act(p(Either.<P1<B>, Actor<B>>left(p(b)), r));
       }
     });
     to(ab.promise().contramap(f));
@@ -233,7 +233,7 @@ public static <A, B, C> F<Promise<A>, F<Promise<B>, Promise<C>>> liftM2(final F<
    * @return A single promise for the given List.
    */
   public static <A> Promise<List<A>> sequence(final Strategy<Unit> s, final List<Promise<A>> as) {
-    return join(foldRight(s, liftM2(List.<A>cons()), promise(s, P.p(List.<A>nil()))).f(as));
+    return join(foldRight(s, liftM2(List.<A>cons()), promise(s, p(List.<A>nil()))).f(as));
   }
 
   /**
@@ -254,7 +254,7 @@ public static <A> F<List<Promise<A>>, Promise<List<A>>> sequence(final Strategy<
    * @return A single promise for the given Stream.
    */
   public static <A> Promise<Stream<A>> sequence(final Strategy<Unit> s, final Stream<Promise<A>> as) {
-    return join(foldRightS(s, curry((Promise<A> o, P1<Promise<Stream<A>>> p) -> o.bind(a -> p._1().fmap(Stream.<A>cons_().f(a)))), promise(s, P.p(Stream.<A>nil()))).f(as));
+    return join(foldRightS(s, curry((Promise<A> o, P1<Promise<Stream<A>>> p) -> o.bind(a -> p._1().fmap(Stream.<A>cons_().f(a)))), promise(s, p(Stream.<A>nil()))).f(as));
   }
 
   /**
@@ -289,7 +289,7 @@ public static <A> Promise<P1<A>> sequence(final Strategy<Unit> s, final P1<Promi
   public static <A, B> F<List<A>, Promise<B>> foldRight(final Strategy<Unit> s, final F<A, F<B, B>> f, final B b) {
     return new F<List<A>, Promise<B>>() {
       public Promise<B> f(final List<A> as) {
-        return as.isEmpty() ? promise(s, p(b)) : liftM2(f).f(promise(s, P.p(as.head()))).f(
+        return as.isEmpty() ? promise(s, p(b)) : liftM2(f).f(promise(s, p(as.head()))).f(
             join(s, P1.curry(this).f(as.tail())));
       }
     };
@@ -307,7 +307,7 @@ public static <A, B> F<Stream<A>, Promise<B>> foldRightS(final Strategy<Unit> s,
                                                            final B b) {
     return new F<Stream<A>, Promise<B>>() {
       public Promise<B> f(final Stream<A> as) {
-        return as.isEmpty() ? promise(s, P.p(b)) : liftM2(f).f(promise(s, P.p(as.head()))).f(
+        return as.isEmpty() ? promise(s, p(b)) : liftM2(f).f(promise(s, p(as.head()))).f(
                 Promise.<P1<B>>join(s, P.lazy(() -> f(as.tail()._1()).fmap(P.<B>p1()))));
       }
     };
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index f9ed8abb..d9231cb8 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -859,7 +859,7 @@ public static <A, B> P2<Array<A>, Array<B>> unzip(final Array<P2<A, B>> xs) {
       aa.set(i, p._1());
       ab.set(i, p._2());
     }
-    return P.p(aa, ab);
+    return p(aa, ab);
   }
 
   /**
@@ -1074,8 +1074,8 @@ public static <T, U> T[] copyOf(final U[] a, final int len, final Class<? extend
     final T[] copy = (Object)newType == Object[].class
         ? (T[]) new Object[len]
         : (T[]) java.lang.reflect.Array.newInstance(newType.getComponentType(), len);
-    System.arraycopy(a, 0, copy, 0,
-        Math.min(a.length, len));
+    arraycopy(a, 0, copy, 0,
+        min(a.length, len));
     return copy;
   }
 
@@ -1089,8 +1089,8 @@ public static char[] copyOfRange(final char[] a, final int from, final int to) {
       if (len < 0)
           throw new IllegalArgumentException(from + " > " + to);
       final char[] copy = new char[len];
-      System.arraycopy(a, from, copy, 0,
-                       Math.min(a.length - from, len));
+      arraycopy(a, from, copy, 0,
+                       min(a.length - from, len));
       return copy;
   }
 }
diff --git a/core/src/main/java/fj/data/Conversions.java b/core/src/main/java/fj/data/Conversions.java
index f6cfb624..055da1dd 100644
--- a/core/src/main/java/fj/data/Conversions.java
+++ b/core/src/main/java/fj/data/Conversions.java
@@ -293,7 +293,7 @@ public static <A> F<Effect1<A>, F<A, Unit>> Effect1_F() {
     public static IO<Unit> Effect_IO(Effect0 e) {
         return () ->{
             e.f();
-            return Unit.unit();
+            return unit();
         };
     }
 
diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index 3f7b2fe3..7e44ef9b 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -104,7 +104,7 @@ public static <A> DList<A> single(A a) {
      * @return the new DList.
      */
     public DList<A> cons(A a) {
-        return DList.single(a).append(this);
+        return single(a).append(this);
     }
     
     /**
@@ -113,7 +113,7 @@ public DList<A> cons(A a) {
      * @return the new DList.
      */
     public DList<A> snoc(A a) {
-        return this.append(DList.single(a));
+        return this.append(single(a));
     }
     
     /**
diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 8581664f..6381ee78 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -417,7 +417,7 @@ public Collection<A> toCollection() {
    public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
        return isLeft() ?
                f.f(value()).map(x -> Either.<C, B>left(x)) :
-               Option.some(Either.<C, B>right(e.right().value()));
+               some(Either.<C, B>right(e.right().value()));
    }
 
   public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
@@ -561,7 +561,7 @@ public <X> Either<A, X> sequence(final Either<A, X> e) {
     */
       public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> Either.right(x)) :
+                  f.f(value()).map(x -> right(x)) :
                   list(Either.<A, C>left(e.left().value()));
       }
 
@@ -580,13 +580,13 @@ public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
           return isRight() ?
                   f.f(value()).map(x -> Either.<A, C>right(x)) :
-                  P.p(Either.<A, C>left(e.left().value()));
+                  p(Either.<A, C>left(e.left().value()));
       }
 
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
           return isRight() ?
                   f.f(value()).map(x -> Either.<A, C>right(x)) :
-                  Option.some(Either.<A, C>left(e.left().value()));
+                  some(Either.<A, C>left(e.left().value()));
       }
 
     /**
@@ -693,8 +693,8 @@ public Collection<B> toCollection() {
 
       public <C> Stream<Either<A, C>> traverseStream(F<B, Stream<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> Either.right(x)) :
-                  Stream.<Either<A,C>>single(Either.left(e.left().value()));
+                  f.f(value()).map(x -> right(x)) :
+                  Stream.<Either<A,C>>single(left(e.left().value()));
 
       }
   }
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index fe57a643..cc143f33 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -368,12 +368,12 @@ else if (l < 0L) {
    * An enumerator for <code>Natural</code>
    */
   public static final Enumerator<Natural> naturalEnumerator = enumerator(
-      n -> Option.some(n.succ()),
+      n -> some(n.succ()),
       n -> n.pred(),
       Option.<Natural>none(), some(Natural.ZERO), naturalOrd,
       curry((n, l) ->
         some(n).apply(
-          Natural.natural(l).map(Function.curry((n1, n2) -> n1.add(n2)))
+          Natural.natural(l).map(curry((n1, n2) -> n1.add(n2)))
         )
       )
   );
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index 3e6ff3b3..cde1e607 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -347,7 +347,7 @@ public static <K, V> HashMap<K, V> fromMap(java.util.Map<K, V> map) {
   }
 
   public static <K, V> HashMap<K, V> fromMap(Equal<K> eq, Hash<K> h, java.util.Map<K, V> map) {
-    HashMap<K, V> m = HashMap.hashMap(eq, h);
+    HashMap<K, V> m = hashMap(eq, h);
     for (Map.Entry<K, V> e: map.entrySet()) {
       m.set(e.getKey(), e.getValue());
     }
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 1a3e93ff..755ce9fa 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -126,7 +126,7 @@ public static <A> IO<IterV<Character, A>> enumFileChars(final File f, final Opti
     }
 
     public static IO<BufferedReader> bufferedReader(final File f, final Option<Charset> encoding) {
-        return IOFunctions.map(fileReader(f, encoding), a -> new BufferedReader(a));
+        return map(fileReader(f, encoding), a -> new BufferedReader(a));
     }
 
     public static IO<Reader> fileReader(final File f, final Option<Charset> encoding) {
@@ -372,15 +372,15 @@ public static IO<Unit> unless(final Boolean b, final IO<Unit> io) {
      */
     public static <A> IO<List<A>> sequence(List<IO<A>> list) {
         F2<IO<A>, IO<List<A>>, IO<List<A>>> f2 = (io, ioList) ->
-                IOFunctions.bind(ioList, (xs) -> map(io, x -> List.cons(x, xs)));
-        return list.foldRight(f2, IOFunctions.unit(List.<A>nil()));
+                bind(ioList, (xs) -> map(io, x -> List.cons(x, xs)));
+        return list.foldRight(f2, unit(List.<A>nil()));
     }
 
 
     public static <A> IO<Stream<A>> sequence(Stream<IO<A>> stream) {
         F2<IO<Stream<A>>, IO<A>, IO<Stream<A>>> f2 = (ioList, io) ->
-                IOFunctions.bind(ioList, (xs) -> map(io, x -> Stream.cons(x, () -> xs)));
-        return stream.foldLeft(f2, IOFunctions.unit(Stream.<A>nil()));
+                bind(ioList, (xs) -> map(io, x -> Stream.cons(x, () -> xs)));
+        return stream.foldLeft(f2, unit(Stream.<A>nil()));
     }
 
 
@@ -418,7 +418,7 @@ public static <A, B> IO<B> flatMap(final IO<A> io, final F<A, IO<B>> f) {
      * @param transform Function to change line value
      */
     public static IO<Unit> interactWhile(F<String, Boolean> condition, F<String, String> transform) {
-        Stream<IO<String>> s1 = Stream.repeat(IOFunctions.stdinReadLine());
+        Stream<IO<String>> s1 = Stream.repeat(stdinReadLine());
         IO<Stream<String>> io = sequenceWhile(s1, condition);
         return () -> runSafe(io).foreach(s -> runSafe(stdoutPrintln(transform.f(s))));
     }
@@ -507,7 +507,7 @@ public static IO<Unit> stdoutPrint(final String s) {
 
     public static IO<LazyString> getContents() {
         Stream<IO<Integer>> s = Stream.<IO<Integer>>repeat(() -> (int) stdinBufferedReader.read());
-        return IOFunctions.map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> {
+        return map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> {
             return (char) i.intValue();
         })));
     }
diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index 8b1b2ac6..adb0c7af 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -40,6 +40,6 @@ public IOW<LazyString> getContents() {
     }
 
     public IOW<Unit> interact(F<LazyString, LazyString> f) {
-        return IOW.lift(() -> IOFunctions.interact(f).run());
+        return lift(() -> IOFunctions.interact(f).run());
     }
 }
diff --git a/core/src/main/java/fj/data/IterableW.java b/core/src/main/java/fj/data/IterableW.java
index 523b4152..9c701a98 100644
--- a/core/src/main/java/fj/data/IterableW.java
+++ b/core/src/main/java/fj/data/IterableW.java
@@ -420,7 +420,7 @@ public ListIterator<A> listIterator(final int index) {
       }
 
       public List<A> subList(final int fromIndex, final int toIndex) {
-        return wrap(Stream.iterableStream(IterableW.this).drop(fromIndex).take(toIndex - fromIndex)).toStandardList();
+        return wrap(iterableStream(IterableW.this).drop(fromIndex).take(toIndex - fromIndex)).toStandardList();
       }
 
       private ListIterator<A> toListIterator(final Option<Zipper<A>> z) {
diff --git a/core/src/main/java/fj/data/LazyString.java b/core/src/main/java/fj/data/LazyString.java
index 95160de1..2583621f 100644
--- a/core/src/main/java/fj/data/LazyString.java
+++ b/core/src/main/java/fj/data/LazyString.java
@@ -224,7 +224,7 @@ public LazyString reverse() {
    * @return The first index of the given character in this lazy string, or None if the character is not present.
    */
   public Option<Integer> indexOf(final char c) {
-    return s.indexOf(Equal.charEqual.eq(c));
+    return s.indexOf(charEqual.eq(c));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 26ec5e33..f12d5a26 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -122,7 +122,7 @@ public final boolean isNotEmpty() {
    */
   @Deprecated
   public final <B> B list(final B nil, final F<A, F<List<A>, B>> cons) {
-    return uncons(Function.uncurryF2(cons), nil);
+    return uncons(uncurryF2(cons), nil);
   }
 
   public final <B> B uncons(final F2<A, List<A>, B> cons, final B nil) {
@@ -410,9 +410,9 @@ public final P2<List<A>, List<A>> span(final F<A, Boolean> p) {
       if (p.f(xs.head()))
         b.snoc(xs.head());
       else
-        return P.p(b.toList(), xs);
+        return p(b.toList(), xs);
     }
-    return P.p(b.toList(), List.<A>nil());
+    return p(b.toList(), List.<A>nil());
   }
 
   /**
@@ -614,7 +614,7 @@ public final <B> List<B> sequence(final List<B> bs) {
     public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
         return foldRight(
                 (a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),
-                Option.some(List.<B>nil())
+                some(List.<B>nil())
         );
     }
 
@@ -641,7 +641,7 @@ public <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
     public <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
         return foldRight(
                 (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-                P.p(List.<B>nil())
+                p(List.<B>nil())
         );
     }
 
@@ -656,7 +656,7 @@ public <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
     return this.foldRight(
         (a, acc) -> Function.bind(acc,
             (bs) -> Function.<C, B, List<B>> compose(b -> bs.cons(b), f.f(a))),
-        Function.constant(List.<B> nil())
+        constant(List.<B> nil())
         );
   }
 
@@ -675,7 +675,7 @@ public <B> Promise<List<B>> traversePromise(final F<A, Promise<B>> f) {
   public <B> List<List<B>> traverseList(final F<A, List<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        List.single(List.<B> nil()));
+        single(List.<B> nil()));
   }
 
   public <E, B> Validation<E, List<B>> traverseValidation(final F<A, Validation<E, B>> f) {
@@ -707,7 +707,7 @@ public final <B> List<B> apply(final List<F<A, B>> lf) {
    * @return A new list that has appended the given list.
    */
   public final List<A> append(final List<A> as) {
-    return Buffer.fromList(this).prependToList(as);
+    return fromList(this).prependToList(as);
   }
 
   /**
@@ -830,7 +830,7 @@ public final A index(final int i) {
    * @return A new list with a length the same, or less than, this list.
    */
   public final List<A> take(final int i) {
-    Buffer<A> result = Buffer.empty();
+    Buffer<A> result = empty();
     List<A> list = this;
     int index = i;
     while (index > 0 && list.isNotEmpty()) {
@@ -868,7 +868,7 @@ public final List<A> drop(final int i) {
   public final P2<List<A>, List<A>> splitAt(final int i) {
     int c = 0;
     List<A> first = List.<A>nil();
-    List<A> second = List.nil();
+    List<A> second = nil();
     for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {
       final A h = xs.head();
       if (c < i) {
@@ -878,7 +878,7 @@ public final P2<List<A>, List<A>> splitAt(final int i) {
       }
       c++;
     }
-    return P.p(first.reverse(), second.reverse());
+    return p(first.reverse(), second.reverse());
   }
 
   /**
@@ -906,10 +906,10 @@ public final List<List<A>> partition(final int n) {
    */
   public P2<List<A>, List<A>> partition(F<A, Boolean> f) {
     P2<List<A>, List<A>> p2 = foldLeft(acc -> a ->
-      f.f(a) ? P.p(acc._1().cons(a), acc._2()) : P.p(acc._1(), acc._2().cons(a)),
-      P.p(nil(), nil())
+      f.f(a) ? p(acc._1().cons(a), acc._2()) : p(acc._1(), acc._2().cons(a)),
+      p(nil(), nil())
     );
-    return P.p(p2._1().reverse(), p2._2().reverse());
+    return p(p2._1().reverse(), p2._2().reverse());
   }
 
   /**
@@ -1115,7 +1115,7 @@ public final Option<A> find(final F<A, Boolean> f) {
   public final List<A> intersperse(final A a) {
     return isEmpty() || tail().isEmpty() ?
            this :
-            cons(head(), tail().bind(a2 -> List.list(a, a2)));
+            cons(head(), tail().bind(a2 -> list(a, a2)));
   }
 
   /**
@@ -1320,7 +1320,7 @@ public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction) {
    * @return A TreeMap containing the keys with the accumulated list of matched elements.
    */
   public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction, final Ord<B> keyOrd) {
-    return groupBy(keyFunction, Function.identity(), keyOrd);
+    return groupBy(keyFunction, identity(), keyOrd);
   }
 
   /**
@@ -1372,7 +1372,7 @@ public final <B, C> TreeMap<B, C> groupBy(
       final Monoid<C> monoid,
       final Ord<B> keyOrd) {
     return groupBy(keyFunction, valueFunction, monoid.zero(),
-        Function.uncurryF2(monoid.sum()), keyOrd);
+        uncurryF2(monoid.sum()), keyOrd);
   }
 
   /**
@@ -1709,7 +1709,7 @@ public static <A, B> P2<List<A>, List<B>> unzip(final List<P2<A, B>> xs) {
       ba = ba.snoc(p._1());
       bb = bb.snoc(p._2());
     }
-    return P.p(ba.toList(), bb.toList());
+    return p(ba.toList(), bb.toList());
   }
 
   /**
@@ -1720,7 +1720,7 @@ public static <A, B> P2<List<A>, List<B>> unzip(final List<P2<A, B>> xs) {
    * @return A list of the given value replicated the given number of times.
    */
   public static <A> List<A> replicate(final int n, final A a) {
-    List<A> list = List.nil();
+    List<A> list = nil();
     for (int i = 0; i < n; i++) { list = list.cons(a); }
     return list;
   }
@@ -1735,7 +1735,7 @@ public static <A> List<A> replicate(final int n, final A a) {
    *         <code>to</code> value (exclusive).
    */
   public static List<Integer> range(final int from, final int to) {
-    final Buffer<Integer> buf = Buffer.empty();
+    final Buffer<Integer> buf = empty();
     for (int i = from; i < to; i++) {
       buf.snoc(i);
     }
@@ -1815,7 +1815,7 @@ public static <A> List<A> single(final A a) {
    */
   public static <A> List<A> iterateWhile(final F<A, A> f, final F<A, Boolean> p, final A a) {
     return unfold(
-            o -> Option.iif(p2 -> p.f(o), P.p(o, f.f(o)))
+            o -> Option.iif(p2 -> p.f(o), p(o, f.f(o)))
             , a);
   }
 
@@ -2210,7 +2210,7 @@ public static <A> Prism<List<A>, Unit> nil() {
      * Cons prism
      */
     public static <A> Prism<List<A>, P2<A, List<A>>> cons() {
-      return prism(l -> l.<Option<P2<A, List<A>>>> list(none(), h -> tail -> some(P.p(h, tail))), c -> List.cons(c._1(), c._2()));
+      return prism(l -> l.<Option<P2<A, List<A>>>> list(none(), h -> tail -> some(p(h, tail))), c -> List.cons(c._1(), c._2()));
     }
 
   }
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index cb58e61f..5bec1ea4 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -432,7 +432,7 @@ public <B> Stream<Option<B>> traverseStream(F<A, Stream<B>> f) {
   }
 
   public <B> P1<Option<B>> traverseP1(F<A, P1<B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(P.p(none()));
+    return map(a -> f.f(a).map(b -> some(b))).orSome(p(none()));
   }
 
   public <B> Seq<Option<B>> traverseSeq(F<A, Seq<B>> f) {
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index 00868ef3..84b26d6e 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -106,7 +106,7 @@ public static <A>Seq<A> listSeq(final List<A> list) {
    * @return A sequence with the elements of the iterable.
    */
   public static <A>Seq<A> iterableSeq(final Iterable<A> i) {
-    Seq<A> s = Seq.empty();
+    Seq<A> s = empty();
     for (final A a: i) {
       s = s.snoc(a);
     }
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index c54d6cb7..2d87234f 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -79,7 +79,7 @@ public State<S, S> gets() {
 	}
 
 	public static <S> State<S, Unit> put(S s) {
-		return State.unit((S z) -> p(s, Unit.unit()));
+		return unit((S z) -> p(s, Unit.unit()));
 	}
 
 	public A eval(S s) {
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index cb6fe8d0..485ca1ad 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -351,7 +351,7 @@ public final Stream<A> removeAll(final F<A, Boolean> f) {
    *         and returns a stream of the results.
    */
   public static <A, B> F<B, Stream<A>> sequence_(final Stream<F<B, A>> fs) {
-    return fs.foldRight((baf, p1) -> Function.bind(baf, p1._1(), Function.curry((a, stream) -> cons(a, p(stream)))), Function
+    return fs.foldRight((baf, p1) -> Function.bind(baf, p1._1(), curry((a, stream) -> cons(a, p(stream)))), Function
             .<B, Stream<A>>constant(Stream.<A>nil()));
   }
 
@@ -531,7 +531,7 @@ public static <A> Stream<IO<A>> sequence(final IO<Stream<A>> io) {
    * @return The stream of (pre-calculated) lazy values after sequencing.
    */
   public static <A> Stream<P1<A>> sequence(final F0<Stream<A>> p) {
-    return p.f().map(a -> P.p(a));
+    return p.f().map(a -> p(a));
   }
 
   /**
@@ -541,7 +541,7 @@ public static <A> Stream<P1<A>> sequence(final F0<Stream<A>> p) {
    * @return The stream of options after sequencing.
    */
   public static <A> Stream<Option<A>> sequence(final Option<Stream<A>> o) {
-    return o.isNone() ? Stream.nil() : o.some().map(a -> Option.some(a));
+    return o.isNone() ? nil() : o.some().map(a -> some(a));
   }
 
   /**
@@ -566,9 +566,9 @@ public final Stream<A> interleave(final Stream<A> as) {
 
   public static <A> Stream<A> enumerationStream(Enumeration<A> e) {
     if (e.hasMoreElements()) {
-      return Stream.cons(e.nextElement(), () -> enumerationStream(e));
+      return cons(e.nextElement(), () -> enumerationStream(e));
     } else {
-      return Stream.nil();
+      return nil();
     }
   }
 
@@ -627,7 +627,7 @@ public final Stream<A> sort(final Ord<A> o, final Strategy<Unit> s) {
 
   private Promise<Stream<A>> qs(final Ord<A> o, final Strategy<Unit> s) {
     if (isEmpty())
-      return promise(s, P.p(this));
+      return promise(s, p(this));
     else {
       final F<Boolean, Boolean> id = identity();
       final A x = head();
@@ -797,7 +797,7 @@ public static <A> Stream<A> range(final Enumerator<A> e, final A from, final A t
    */
   public static <A> Stream<A> range(final Enumerator<A> e, final A from, final A to, final long step) {
     final Ordering o = e.order().compare(from, to);
-    return o == EQ || step > 0L && o == GT || step < 0L && o == LT ? single(from) : cons(from, () -> Stream.join(e.plus(from, step).filter(a -> !(o == LT
+    return o == EQ || step > 0L && o == GT || step < 0L && o == LT ? single(from) : cons(from, () -> join(e.plus(from, step).filter(a -> !(o == LT
                 ? e.order().isLessThan(to, a)
                 : e.order().isGreaterThan(to, a))).map(a1 -> range(e, a1, to, step)).toStream()));
   }
@@ -1336,7 +1336,7 @@ public final Stream<Stream<A>> tails() {
    * @return a stream of the prefixes of this stream, starting with the stream itself.
    */
   public final Stream<Stream<A>> inits() {
-    final Stream<Stream<A>> nil = Stream.cons(Stream.<A>nil(), () -> nil());
+    final Stream<Stream<A>> nil = cons(Stream.<A>nil(), () -> nil());
     return isEmpty() ? nil : nil.append(() -> tail()._1().inits().map(Stream.<A>cons_().f(head())));
   }
 
@@ -1418,8 +1418,8 @@ public static <A, B> Stream<A> fromFunction(final Enumerator<B> e, final F<B, A>
   public static <A, B> P2<Stream<A>, Stream<B>> unzip(final Stream<P2<A, B>> xs) {
     return xs.foldRight((p, ps) -> {
       final P2<Stream<A>, Stream<B>> pp = ps._1();
-      return P.p(cons(p._1(), P.p(pp._1())), cons(p._2(), P.p(pp._2())));
-    }, P.p(Stream.<A>nil(), Stream.<B>nil()));
+      return p(cons(p._1(), p(pp._1())), cons(p._2(), p(pp._2())));
+    }, p(Stream.<A>nil(), Stream.<B>nil()));
   }
 
   /**
@@ -1591,7 +1591,7 @@ public static <A, B> Stream<A> unfold(final F<B, Option<P2<A, B>>> f, final B b)
    */
   public static <A> Stream<A> iterateWhile(final F<A, A> f, final F<A, Boolean> p, final A a) {
     return unfold(
-            o -> Option.iif(p2 -> p.f(o), P.p(o, f.f(o)))
+            o -> Option.iif(p2 -> p.f(o), p(o, f.f(o)))
             , a);
   }
 
@@ -1609,7 +1609,7 @@ public static <A> Stream<A> iterableStream(final Iterable<A> i) {
   public static <A> Stream<A> arrayStream(final A...as) {
     return as.length == 0 ? Stream.<A>nil()
             : unfold(P2.tuple((as1, i) -> i >= as.length ? Option.<P2<A, P2<A[], Integer>>>none()
-            : some(P.p(as[i], P.p(as, i + 1)))), P.p(as, 0));
+            : some(p(as[i], p(as, i + 1)))), p(as, 0));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index f02a6e73..004e0910 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -252,7 +252,7 @@ private static <A> Stream<String> drawSubTrees(final Show<A> s, final Stream<Tre
   }
 
   private static Stream<String> shift(final String f, final String o, final Stream<String> s) {
-    return Stream.repeat(o).cons(f).zipWith(s, Monoid.stringMonoid.sum());
+    return repeat(o).cons(f).zipWith(s, Monoid.stringMonoid.sum());
   }
 
   private Stream<String> drawTree(final Show<A> s) {
@@ -328,7 +328,7 @@ public <B, C> Tree<C> zipWith(final Tree<B> bs, final F<A, F<B, C>> f) {
   public static <A, B> Tree<B> bottomUp(Tree<A> t, final F<P2<A, Stream<B>>, B> f) {
     final F<Tree<A>, Tree<B>> recursiveCall = a -> bottomUp(a, f);
     final Stream<Tree<B>> tbs = t.subForest()._1().map(recursiveCall);
-    return Tree.node(f.f(P.p(t.root(), tbs.map(Tree.<B> getRoot()))), tbs);
+    return node(f.f(P.p(t.root(), tbs.map(Tree.<B> getRoot()))), tbs);
    }
  
    /**
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index e35e6592..2bdf70a9 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -129,7 +129,7 @@ public static <K, V> TreeMap<K, V> arrayTreeMap(final Ord<K> keyOrd, final P2<K,
    * @return A potential value for the given key.
    */
   public Option<V> get(final K k) {
-    final Option<P2<K, Option<V>>> x = tree.split(P.p(k, Option.<V>none()))._2();
+    final Option<P2<K, Option<V>>> x = tree.split(p(k, Option.<V>none()))._2();
     return x.bind(P2.<K, Option<V>>__2());
   }
 
@@ -142,7 +142,7 @@ public Option<V> get(final K k) {
    * @return A new tree map with the given value mapped to the given key.
    */
   public TreeMap<K, V> set(final K k, final V v) {
-      return new TreeMap<K, V>(tree.insert(P.p(k, Option.some(v))));
+      return new TreeMap<K, V>(tree.insert(p(k, Option.some(v))));
   }
 
   /**
@@ -152,7 +152,7 @@ public TreeMap<K, V> set(final K k, final V v) {
    * @return A new tree map with the entry corresponding to the given key removed.
    */
   public TreeMap<K, V> delete(final K k) {
-    return new TreeMap<K, V>(tree.delete(P.p(k, Option.<V>none())));
+    return new TreeMap<K, V>(tree.delete(p(k, Option.<V>none())));
   }
 
   /**
@@ -198,7 +198,7 @@ public List<K> keys() {
    * @return <code>true</code> if this tree map contains the given key, <code>false</code> otherwise.
    */
   public boolean contains(final K k) {
-    return tree.member(P.p(k, Option.<V>none()));
+    return tree.member(p(k, Option.<V>none()));
   }
 
   /**
@@ -218,7 +218,7 @@ public Iterator<P2<K, V>> iterator() {
    * @return A new mutable map isomorphic to this tree map.
    */
   public Map<K, V> toMutableMap() {
-    final F<K, P2<K, Option<V>>> fakePair = k -> P.p(k, Option.none());
+    final F<K, P2<K, Option<V>>> fakePair = k -> p(k, Option.none());
 	final Comparator<K> comparator = tree.ord().contramap(fakePair).toComparator();
 	final Map<K, V> m = new java.util.TreeMap<K, V>(comparator);
     for (final P2<K, V> e : this) {
@@ -278,7 +278,7 @@ public F<K, Option<V>> get() {
   public P2<Boolean, TreeMap<K, V>> update(final K k, final F<V, V> f) {
     final P2<Boolean, Set<P2<K, Option<V>>>> up =
         tree.update(p(k, Option.<V>none()), compose(P2.tuple(P.p2()), P2.<K, Option<V>, Option<V>>map2_(Option.<V, V>map().f(f))));
-    return P.p(up._1(), new TreeMap<K, V>(up._2()));
+    return p(up._1(), new TreeMap<K, V>(up._2()));
   }
 
   /**
@@ -347,9 +347,9 @@ private static <K, V> TreeMap<K, V> treeMap(Ord<K> ord, Set<P2<K, Option<V>>> s)
    * given key if present, otherwise None.
    */
   public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
-    P3<Set<P2<K, Option<V>>>, Option<P2<K, Option<V>>>, Set<P2<K, Option<V>>>> p3 = tree.split(P.p(k, get(k)));
-    Ord<K> o = tree.ord().<K>contramap(k2 -> P.p(k2, Option.<V>none()));
-    return P.p(treeMap(o, p3._1()), get(k), treeMap(o, p3._3()));
+    P3<Set<P2<K, Option<V>>>, Option<P2<K, Option<V>>>, Set<P2<K, Option<V>>>> p3 = tree.split(p(k, get(k)));
+    Ord<K> o = tree.ord().<K>contramap(k2 -> p(k2, Option.<V>none()));
+    return p(treeMap(o, p3._1()), get(k), treeMap(o, p3._3()));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index a87b4585..3e622f68 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -208,7 +208,7 @@ public static <E, A> Validation<E, List<A>> sequence(final Semigroup<E> s, final
     if (list.exists(v -> v.isFail())) {
       return Validation.<E, List<A>>fail(list.filter(v -> v.isFail()).map(v -> v.fail()).foldLeft1((e1, e2) -> s.sum(e1, e2)));
     } else {
-      return Validation.success(list.foldLeft((List<A> acc, Validation<E, A> v) -> acc.cons(v.success()), List.nil()).reverse());
+      return success(list.foldLeft((List<A> acc, Validation<E, A> v) -> acc.cons(v.success()), List.nil()).reverse());
     }
   }
 
@@ -722,17 +722,17 @@ public Iterator<T> iterator() {
 
     public Validation<List<E>, T> accumulate() {
         if (isFail()) {
-            return Validation.fail(List.<E>single(fail()));
+            return fail(List.<E>single(fail()));
         } else {
-            return Validation.success(success());
+            return success(success());
         }
     }
 
     public <B> Validation<List<E>, B> accumulate(F<T, B> f) {
         if (isFail()) {
-            return Validation.fail(List.<E>single(fail()));
+            return fail(List.<E>single(fail()));
         } else {
-            return Validation.success(f.f(success()));
+            return success(f.f(success()));
         }
     }
 
@@ -746,9 +746,9 @@ public <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C>
             list = list.cons(v2.fail());
         }
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success()));
+            return success(f.f(success(), v2.success()));
         }
     }
 
@@ -757,27 +757,27 @@ public <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C>
     public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validation<E, C> v3, F3<T, B, C, D> f) {
         List<E> list = fails(list(this, v2, v3));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success()));
+            return success(f.f(success(), v2.success(), v3.success()));
         }
     }
 
     public <B, C, D, $E> Validation<List<E>, $E> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, F4<T, B, C, D, $E> f) {
         List<E> list = fails(list(this, v2, v3, v4));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success(), v4.success()));
+            return success(f.f(success(), v2.success(), v3.success(), v4.success()));
         }
     }
 
     public <B, C, D, $E, $F> Validation<List<E>, $F> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, F5<T, B, C, D, $E, $F> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success()));
+            return success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success()));
         }
     }
 
@@ -785,27 +785,27 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
     public <B, C, D, $E, $F, G> Validation<List<E>, G> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, F6<T, B, C, D, $E, $F, G> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success()));
+            return success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success()));
         }
     }
 
     public <B, C, D, $E, $F, G, H> Validation<List<E>, H> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, F7<T, B, C, D, $E, $F, G, H> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success(), v7.success()));
+            return success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success(), v7.success()));
         }
     }
 
     public <B, C, D, $E, $F, G, H, I> Validation<List<E>, I> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, Validation<E, H> v8, F8<T, B, C, D, $E, $F, G, H, I> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
-            return Validation.fail(list);
+            return fail(list);
         } else {
-            return Validation.success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success(), v7.success(), v8.success()));
+            return success(f.f(success(), v2.success(), v3.success(), v4.success(), v5.success(), v6.success(), v7.success(), v8.success()));
         }
     }
 
@@ -818,10 +818,10 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
     public static <A, E> Validation<List<E>, List<A>> sequenceNonCumulative(List<Validation<E, A>> list) {
       if (list.exists(v -> v.isFail())) {
         F2<List<E>, Validation<E, A>, List<E>> f = (acc, v) -> acc.cons(v.fail());
-        return Validation.fail(list.filter(v -> v.isFail()).foldLeft(f, List.nil()).reverse());
+        return fail(list.filter(v -> v.isFail()).foldLeft(f, List.nil()).reverse());
       } else {
         F2<List<A>, Validation<E, A>, List<A>> f = (acc, v) -> acc.cons(v.success());
-        return Validation.success(list.filter(v -> v.isSuccess()).foldLeft(f, List.nil()).reverse());
+        return success(list.filter(v -> v.isSuccess()).foldLeft(f, List.nil()).reverse());
       }
     }
 
@@ -852,7 +852,7 @@ public <C> IO<Validation<E, C>> traverseIO(F<T, IO<C>> f){
     public <C> P1<Validation<E, C>> traverseP1(F<T, P1<C>> f){
         return isSuccess() ?
                 f.f(success()).map(Validation::success) :
-                P.p(fail(e.left().value()));
+                p(fail(e.left().value()));
     }
 
 
@@ -1276,7 +1276,7 @@ public static Validation<NumberFormatException, Short> parseShort(final String s
    * Partitions the list into the list of fails and the list of successes
    */
   public static <A, B> P2<List<A>, List<B>> partition(List<Validation<A, B>> list) {
-    return P.p(
+    return p(
             list.filter(v -> v.isFail()).map(v -> v.fail()),
             list.filter(v -> v.isSuccess()).map(v -> v.success())
     );
diff --git a/core/src/main/java/fj/data/Writer.java b/core/src/main/java/fj/data/Writer.java
index 7ff57d07..b384e259 100644
--- a/core/src/main/java/fj/data/Writer.java
+++ b/core/src/main/java/fj/data/Writer.java
@@ -59,7 +59,7 @@ public static <B> Writer<String, B> unit(B b) {
 	}
 
 	public static <A> F<A, Writer<String, A>> stringLogger() {
-		return a -> Writer.unit(a, Monoid.stringMonoid);
+		return a -> unit(a, Monoid.stringMonoid);
 	}
 
 }
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index 9f86db45..1078374b 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -225,7 +225,7 @@ public final P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean
     public abstract int length();
 
     public static <A> FingerTree<Integer, A> emptyIntAddition() {
-        return FingerTree.mkTree(FingerTree.<Integer, A>measured(intAdditionMonoid, Function.constant(1))).empty();
+        return mkTree(FingerTree.<Integer, A>measured(intAdditionMonoid, Function.constant(1))).empty();
     }
 
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Single.java b/core/src/main/java/fj/data/fingertrees/Single.java
index 410378f1..1bbe7884 100644
--- a/core/src/main/java/fj/data/fingertrees/Single.java
+++ b/core/src/main/java/fj/data/fingertrees/Single.java
@@ -81,7 +81,7 @@ public V measure() {
 
   @Override P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate, final V acc) {
     final Empty<V, A> empty = new Empty<>(measured());
-    return P.p(empty, a, empty);
+    return p(empty, a, empty);
   }
 
   @Override public P2<Integer, A> lookup(final F<V, Integer> o, final int i) { return p(i, a); }
diff --git a/demo/src/main/java/fj/demo/realworld/Chapter7.java b/demo/src/main/java/fj/demo/realworld/Chapter7.java
index 2f6ed8a4..f9263683 100644
--- a/demo/src/main/java/fj/demo/realworld/Chapter7.java
+++ b/demo/src/main/java/fj/demo/realworld/Chapter7.java
@@ -36,7 +36,7 @@ public static void toUpperLazy() {
      * Read each line, convert to uppercase and print on stdout, until an empty line
      */
     public static void toUpperByLine() {
-        Stream<IO<String>> s1 = Stream.repeat(IOFunctions.stdinReadLine());
+        Stream<IO<String>> s1 = Stream.repeat(stdinReadLine());
         IO<Stream<String>> io = sequenceWhile(s1, s -> s.trim().length() > 0);
         runSafe(io).foreachDoEffect(s -> runSafe(stdoutPrintln(s.toUpperCase())));
     }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 34a17ae1..5222df9e 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -128,7 +128,7 @@ public Gen<B> f(final A x) {
   }
 
     public static <A, B> Arbitrary<Reader<A, B>> arbReader(Coarbitrary<A> aa, Arbitrary<B> ab) {
-        return arbitrary(Arbitrary.arbF(aa, ab).gen.map(f -> Reader.unit(f)));
+        return arbitrary(arbF(aa, ab).gen.map(f -> Reader.unit(f)));
     }
 
     /**
@@ -819,7 +819,7 @@ public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa) {
 	}
 
     public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa, int max) {
-        Gen<Set<A>> g = Gen.choose(0, max).bind(i -> Gen.sequenceN(i, aa.gen)).map(list -> Set.iterableSet(ord, list));
+        Gen<Set<A>> g = choose(0, max).bind(i -> Gen.sequenceN(i, aa.gen)).map(list -> Set.iterableSet(ord, list));
         return arbitrary(g);
     }
 
@@ -902,7 +902,7 @@ public Date f(final Long i) {
    * @return An arbitrary for instances of the supplied enum type.
    */
   public static <A extends Enum<A>> Arbitrary<A> arbEnumValue(final Class<A> clazz) {
-    return arbitrary(Gen.elements(clazz.getEnumConstants()));
+    return arbitrary(elements(clazz.getEnumConstants()));
   }
 
   /**
@@ -1161,7 +1161,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
             if (i < 0) {
                 Bottom.error("Undefined: arbitrary natural is negative (" + i + ")");
             }
-            return Gen.sequenceN(Math.max(i, 0), Arbitrary.arbP2(ak, av).gen);
+            return Gen.sequenceN(Math.max(i, 0), arbP2(ak, av).gen);
         });
         return arbTreeMap(ord, arbitrary(gl2));
     }
@@ -1173,7 +1173,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
         if (maxSize < 0) {
             Bottom.error("Undefined: arbitrary natural is negative (" + maxSize + ")");
         }
-        return arbTreeMap(ord, ak, av, arbitrary(Gen.choose(0, maxSize)));
+        return arbTreeMap(ord, ak, av, arbitrary(choose(0, maxSize)));
     }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 3231cf2e..1486a695 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -367,7 +367,7 @@ public Result f(final Rand r) {
      * will be taken from the given boolean b.
      */
     public static Property impliesBoolean(final boolean a, final boolean b) {
-        return implies(a, () -> Property.prop(b));
+        return implies(a, () -> prop(b));
     }
 
     /**
@@ -375,7 +375,7 @@ public static Property impliesBoolean(final boolean a, final boolean b) {
      * will be taken from the given lazy boolean b.
      */
     public static Property impliesBoolean(final boolean a, final F0<Boolean> b) {
-        return implies(a, () -> Property.prop(b.f()));
+        return implies(a, () -> prop(b.f()));
     }
 
   /**

From 3655b4d143cb3a52d604ea41da110839684c9b74 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 20:17:43 +0100
Subject: [PATCH 033/336] Remove redundant public/abstract modifiers on
 interfaces

---
 core/src/main/java/fj/F.java           | 2 +-
 core/src/main/java/fj/F0.java          | 2 +-
 core/src/main/java/fj/F2.java          | 2 +-
 core/src/main/java/fj/F3.java          | 2 +-
 core/src/main/java/fj/F4.java          | 2 +-
 core/src/main/java/fj/F5.java          | 2 +-
 core/src/main/java/fj/F6.java          | 2 +-
 core/src/main/java/fj/F7.java          | 2 +-
 core/src/main/java/fj/F8.java          | 2 +-
 core/src/main/java/fj/data/IO.java     | 2 +-
 core/src/main/java/fj/data/SafeIO.java | 2 +-
 11 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/core/src/main/java/fj/F.java b/core/src/main/java/fj/F.java
index 1b524fdc..2a0136bf 100644
--- a/core/src/main/java/fj/F.java
+++ b/core/src/main/java/fj/F.java
@@ -45,6 +45,6 @@ public interface F<A, B> {
    * @param a The <code>A</code> to transform.
    * @return The result of the transformation.
    */
-  public abstract B f(A a);
+  B f(A a);
 
 }
diff --git a/core/src/main/java/fj/F0.java b/core/src/main/java/fj/F0.java
index e85689da..eab82a01 100644
--- a/core/src/main/java/fj/F0.java
+++ b/core/src/main/java/fj/F0.java
@@ -5,6 +5,6 @@
  */
 public interface F0<A> {
 
-    public A f();
+    A f();
 
 }
diff --git a/core/src/main/java/fj/F2.java b/core/src/main/java/fj/F2.java
index 0aa82585..1723927a 100644
--- a/core/src/main/java/fj/F2.java
+++ b/core/src/main/java/fj/F2.java
@@ -33,6 +33,6 @@ public interface F2<A, B, C> {
    * @param b The <code>B</code> to transform.
    * @return The result of the transformation.
    */
-  public C f(A a, B b);
+  C f(A a, B b);
 
 }
diff --git a/core/src/main/java/fj/F3.java b/core/src/main/java/fj/F3.java
index 68e7627a..540afdaa 100644
--- a/core/src/main/java/fj/F3.java
+++ b/core/src/main/java/fj/F3.java
@@ -15,5 +15,5 @@ public interface F3<A, B, C, D> {
    * @param c The <code>C</code> to transform.
    * @return The result of the transformation.
    */
-  public D f(A a, B b, C c);
+  D f(A a, B b, C c);
 }
diff --git a/core/src/main/java/fj/F4.java b/core/src/main/java/fj/F4.java
index 9447389a..84dcfafa 100644
--- a/core/src/main/java/fj/F4.java
+++ b/core/src/main/java/fj/F4.java
@@ -16,5 +16,5 @@ public interface F4<A, B, C, D, E> {
    * @param d The <code>D</code> to transform.
    * @return The result of the transformation.
    */
-  public E f(A a, B b, C c, D d);
+  E f(A a, B b, C c, D d);
 }
diff --git a/core/src/main/java/fj/F5.java b/core/src/main/java/fj/F5.java
index ff7184f2..5fea676b 100644
--- a/core/src/main/java/fj/F5.java
+++ b/core/src/main/java/fj/F5.java
@@ -19,5 +19,5 @@ public interface F5<A, B, C, D, E, F$> {
    * @param e The <code>E</code> to transform.
    * @return The result of the transformation.
    */
-  public F$ f(A a, B b, C c, D d, E e);
+  F$ f(A a, B b, C c, D d, E e);
 }
diff --git a/core/src/main/java/fj/F6.java b/core/src/main/java/fj/F6.java
index f403eb0a..20101cf7 100644
--- a/core/src/main/java/fj/F6.java
+++ b/core/src/main/java/fj/F6.java
@@ -20,5 +20,5 @@ public interface F6<A, B, C, D, E, F$, G> {
    * @param f The <code>F$</code> to transform.
    * @return The result of the transformation.
    */
-  public G f(A a, B b, C c, D d, E e, F$ f);
+  G f(A a, B b, C c, D d, E e, F$ f);
 }
diff --git a/core/src/main/java/fj/F7.java b/core/src/main/java/fj/F7.java
index be9d87e1..5a3ea1ef 100644
--- a/core/src/main/java/fj/F7.java
+++ b/core/src/main/java/fj/F7.java
@@ -21,5 +21,5 @@ public interface F7<A, B, C, D, E, F$, G, H> {
    * @param g The <code>G</code> to transform.
    * @return The result of the transformation.
    */
-  public H f(A a, B b, C c, D d, E e, F$ f, G g);
+  H f(A a, B b, C c, D d, E e, F$ f, G g);
 }
diff --git a/core/src/main/java/fj/F8.java b/core/src/main/java/fj/F8.java
index 5ad75489..8b986456 100644
--- a/core/src/main/java/fj/F8.java
+++ b/core/src/main/java/fj/F8.java
@@ -22,5 +22,5 @@ public interface F8<A, B, C, D, E, F$, G, H, I> {
    * @param h The <code>H</code> to transform.
    * @return The result of the transformation.
    */
-  public I f(A a, B b, C c, D d, E e, F$ f, G g, H h);
+  I f(A a, B b, C c, D d, E e, F$ f, G g, H h);
 }
diff --git a/core/src/main/java/fj/data/IO.java b/core/src/main/java/fj/data/IO.java
index eefd11b9..ee27bdb7 100644
--- a/core/src/main/java/fj/data/IO.java
+++ b/core/src/main/java/fj/data/IO.java
@@ -15,6 +15,6 @@
  */
 public interface IO<A> {
 
-	public A run() throws IOException;
+	A run() throws IOException;
 
 }
diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index 2935ca83..13bbbcc5 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -8,7 +8,7 @@
 public interface SafeIO<A> extends IO<A> {
 
 	@Override
-	public A run();
+	A run();
 
 }
 

From a60afe9732d7a367fe8eabd3bd7fa9155f18addc Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 20:39:49 +0100
Subject: [PATCH 034/336] Remove unnecessary parentheses

---
 core/src/main/java/fj/Semigroup.java                     | 2 +-
 core/src/main/java/fj/data/Stream.java                   | 2 +-
 core/src/main/java/fj/data/optic/PTraversal.java         | 2 +-
 demo/src/main/java/fj/demo/Array_foldLeft.java           | 2 +-
 demo/src/main/java/fj/demo/StateDemo_VendingMachine.java | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 18172990..5d4b995d 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -92,7 +92,7 @@ static <A> A multiply1p(F<A, F<A, A>> sum, int n, A a) {
         }
       }
       xTmp = sum.f(xTmp).f(xTmp);
-      yTmp = (yTmp) >>> 1;
+      yTmp = yTmp >>> 1;
     }
   }
 
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 485ca1ad..fcb6c1d0 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -374,7 +374,7 @@ public final <B, C> F<B, Stream<C>> mapM(final F<A, F<B, C>> f) {
    * @return A new stream after performing the map, then final join.
    */
   public final <B> Stream<B> bind(final F<A, Stream<B>> f) {
-    return foldRight(h -> (t -> f.f(h).append(t)), nil());
+    return foldRight(h -> t -> f.f(h).append(t), nil());
   }
 
   /**
diff --git a/core/src/main/java/fj/data/optic/PTraversal.java b/core/src/main/java/fj/data/optic/PTraversal.java
index 8e98cf2f..50c1e14c 100644
--- a/core/src/main/java/fj/data/optic/PTraversal.java
+++ b/core/src/main/java/fj/data/optic/PTraversal.java
@@ -533,7 +533,7 @@ public <M> F<S, M> foldMap(final Monoid<M> monoid, final F<A, M> f) {
 
   public static <S, T, A, B> PTraversal<S, T, A, B> pTraversal(final F<S, A> get1, final F<S, A> get2, final F<S, A> get3,
       final F4<B, B, B, S, T> set) {
-    return fromCurried(pTraversal(get1, get2, (b1, b2, s) -> (b3 -> set.f(b1, b2, b3, s))), get3);
+    return fromCurried(pTraversal(get1, get2, (b1, b2, s) -> b3 -> set.f(b1, b2, b3, s)), get3);
   }
 
   public static <S, T, A, B> PTraversal<S, T, A, B> pTraversal(final F<S, A> get1, final F<S, A> get2, final F<S, A> get3,
diff --git a/demo/src/main/java/fj/demo/Array_foldLeft.java b/demo/src/main/java/fj/demo/Array_foldLeft.java
index 9acb86be..f7f1ce58 100644
--- a/demo/src/main/java/fj/demo/Array_foldLeft.java
+++ b/demo/src/main/java/fj/demo/Array_foldLeft.java
@@ -12,7 +12,7 @@ public static void main(final String[] args) {
 
         // WARNING: In JDK 8, update 20 and 25 (current version) the following code triggers an internal JDK compiler error, likely due to https://bugs.openjdk.java.net/browse/JDK-8062253.   The code below is a workaround for this compiler bug.
         //    final int c = a.foldLeft(i -> (j -> i + j), 0);
-        F<Integer, F<Integer, Integer>> add2 = i -> (j -> i + j);
+        F<Integer, F<Integer, Integer>> add2 = i -> j -> i + j;
         final int c = a.foldLeft(add2, 0);
         System.out.println(b); // 1774
     }
diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index 0f09318a..e31c9f27 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -48,7 +48,7 @@ public boolean equals(Object o) {
 		 */
 		@Override
 		public int hashCode() {
-			int result = (locked ? 1 : 0);
+			int result = locked ? 1 : 0;
 			result = 31 * result + items;
 			result = 31 * result + coins;
 			return result;

From 2b7633f5409c3d6a222bf70a3bb8476e61fb2b6e Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 20:40:36 +0100
Subject: [PATCH 035/336] Remove unnecessary semicolon

---
 demo/src/main/java/fj/demo/StateDemo_VendingMachine.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index e31c9f27..3178e37b 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -12,7 +12,7 @@
  */
 public class StateDemo_VendingMachine {
 
-	public enum Input { COIN, TURN };
+	public enum Input { COIN, TURN }
 
 	public static class VendingMachine {
 

From 702202297bc4427556e94ffed84502aad01b52b3 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 16:49:36 +0100
Subject: [PATCH 036/336] Remove usage of deprecated API

---
 core/src/main/java/fj/P1.java            | 4 ++--
 core/src/main/java/fj/data/HashMap.java  | 6 +++---
 core/src/main/java/fj/data/List.java     | 8 ++++----
 core/src/test/java/fj/data/ListTest.java | 4 ++--
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 1995352e..0cb92a89 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -86,7 +86,7 @@ public static <A, B> F<A, P1<B>> curry(final F<A, B> f) {
      */
     public <B> P1<B> apply(final P1<F<A, B>> cf) {
         P1<A> self = this;
-        return cf.bind(f -> fmap(f).f(self));
+        return cf.bind(f -> map_(f).f(self));
     }
 
     /**
@@ -97,7 +97,7 @@ public <B> P1<B> apply(final P1<F<A, B>> cf) {
      * @return A new P1 after performing the map, then final join.
      */
     public <B, C> P1<C> bind(final P1<B> cb, final F<A, F<B, C>> f) {
-        return cb.apply(fmap(f).f(this));
+        return cb.apply(map_(f).f(this));
     }
 
 	/**
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index cde1e607..e45d94a5 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -272,11 +272,11 @@ public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
   }
 
   public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function, Equal<A> equal, Hash<A> hash) {
-    return from(toStream().map(function), equal, hash);
+    return iterableHashMap(equal, hash, toStream().map(function));
   }
 
   public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function) {
-    return from(toStream().map(function));
+    return iterableHashMap(toStream().map(function));
   }
 
   public <A> HashMap<A, V> mapKeys(F<K, A> keyFunction, Equal<A> equal, Hash<A> hash) {
@@ -339,7 +339,7 @@ public java.util.Map<K, V> toMap() {
    */
   @Deprecated
   public static <K, V> HashMap<K, V> from(final Iterable<P2<K, V>> entries) {
-    return iterableHashMap(Equal.<K>anyEqual(), Hash.<K>anyHash(), entries);
+    return iterableHashMap(entries);
   }
 
   public static <K, V> HashMap<K, V> fromMap(java.util.Map<K, V> map) {
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index f12d5a26..31c4a4af 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -2188,15 +2188,15 @@ public static <A> Traversal<List<A>, A> traversal() {
      * Optional targeted on Cons head.
      */
     public static <A> Optional<List<A>, A> head() {
-      return optional(l -> l.toOption(), a -> l -> l.<List<A>>list(l, constant(cons_(a))));
+      return optional(List::headOption, a -> l -> l.uncons((__, as) -> as.cons(a), l));
     }
 
     /**
      * Optional targeted on Cons tail.
      */
     public static <A> Optional<List<A>, List<A>> tail() {
-      return optional(l -> l.<Option<List<A>>> list(none(), h -> tail -> some(tail)),
-              tail -> l -> l.list(l, h -> constant(List.cons(h, tail))));
+      return optional(l -> l.uncons((__, tail) -> some(tail), none()),
+              tail -> l -> l.uncons((h, __) -> List.cons(h, tail), l));
     }
 
     /**
@@ -2210,7 +2210,7 @@ public static <A> Prism<List<A>, Unit> nil() {
      * Cons prism
      */
     public static <A> Prism<List<A>, P2<A, List<A>>> cons() {
-      return prism(l -> l.<Option<P2<A, List<A>>>> list(none(), h -> tail -> some(p(h, tail))), c -> List.cons(c._1(), c._2()));
+      return prism(l -> l.<Option<P2<A, List<A>>>> uncons((h, tail) -> some(p(h, tail)), none()), c -> List.cons(c._1(), c._2()));
     }
 
   }
diff --git a/core/src/test/java/fj/data/ListTest.java b/core/src/test/java/fj/data/ListTest.java
index 8725ef05..3b720fe6 100644
--- a/core/src/test/java/fj/data/ListTest.java
+++ b/core/src/test/java/fj/data/ListTest.java
@@ -82,13 +82,13 @@ public void listReduce() {
     }
 
     @Test
-    public void toJavaArray() {
+    public void array() {
         final int max = 3;
         Integer[] ints = new Integer[max];
         for (int i = 0; i < max; i++) {
             ints[i] = i + 1;
         };
-        assertThat(List.range(1, max + 1).toJavaArray(), equalTo(ints));
+        assertThat(List.range(1, max + 1).array(Integer[].class), equalTo(ints));
     }
 
 }

From 9fa7b497d238f9be83fc23e9b544a9466f1fda29 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 20:59:47 +0100
Subject: [PATCH 037/336] simplify boolean expression

---
 core/src/main/java/fj/Semigroup.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 5d4b995d..6e091d7f 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -240,7 +240,7 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that XORs booleans.
    */
-  public static final Semigroup<Boolean> exclusiveDisjunctionSemiGroup = semigroup((p, q) -> p && !q || !p && q);
+  public static final Semigroup<Boolean> exclusiveDisjunctionSemiGroup = semigroup((p, q) -> p ? !q : q);
 
   /**
    * A semigroup that ANDs booleans.

From 00a5fdc34c5b97758a8a12f34cde4db3dd175f0f Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 21:09:10 +0100
Subject: [PATCH 038/336] Add test for Ordering#reverse

---
 core/src/test/java/fj/OrderingTest.java | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 core/src/test/java/fj/OrderingTest.java

diff --git a/core/src/test/java/fj/OrderingTest.java b/core/src/test/java/fj/OrderingTest.java
new file mode 100644
index 00000000..9b980e67
--- /dev/null
+++ b/core/src/test/java/fj/OrderingTest.java
@@ -0,0 +1,21 @@
+package fj;
+
+import org.hamcrest.Matcher;
+import org.hamcrest.core.Is;
+import org.junit.Test;
+
+import static fj.Ordering.EQ;
+import static fj.Ordering.GT;
+import static fj.Ordering.LT;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class OrderingTest {
+
+  @Test
+  public void reverse() throws Exception {
+    assertThat(GT.reverse(), is(LT));
+    assertThat(LT.reverse(), is(GT));
+    assertThat(EQ.reverse(), is(EQ));
+  }
+}
\ No newline at end of file

From a4fb2dfb6a7eb17db11f4d7f89a0442515fc1f43 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 21:19:46 +0100
Subject: [PATCH 039/336] More regular for loop

---
 core/src/main/java/fj/data/List.java   | 4 +---
 core/src/main/java/fj/data/Stream.java | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 31c4a4af..0b5a0d4c 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -848,11 +848,9 @@ public final List<A> take(final int i) {
    * @return A list with a length the same, or less than, this list.
    */
   public final List<A> drop(final int i) {
-    int c = 0;
-
     List<A> xs = this;
 
-    for (; xs.isNotEmpty() && c < i; xs = xs.tail())
+    for (int c = 0; xs.isNotEmpty() && c < i; xs = xs.tail())
       c++;
 
     return xs;
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index fcb6c1d0..6dbcf778 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -1072,11 +1072,9 @@ public final Stream<A> take(final int n) {
    * @return A stream with a length the same, or less than, this stream.
    */
   public final Stream<A> drop(final int i) {
-    int c = 0;
-
     Stream<A> xs = this;
 
-    for (; xs.isNotEmpty() && c < i; xs = xs.tail()._1())
+    for (int c = 0; xs.isNotEmpty() && c < i; xs = xs.tail()._1())
       c++;
 
     return xs;

From f374e16989844354fc6dc252a1adb017157d45fe Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 21:50:08 +0100
Subject: [PATCH 040/336] Improve error handling in DbState#run

---
 core/src/main/java/fj/control/db/DbState.java | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/core/src/main/java/fj/control/db/DbState.java b/core/src/main/java/fj/control/db/DbState.java
index 1243c309..228dff37 100644
--- a/core/src/main/java/fj/control/db/DbState.java
+++ b/core/src/main/java/fj/control/db/DbState.java
@@ -94,18 +94,21 @@ public Unit run(final Connection c) throws SQLException {
    * @throws SQLException in case of a database error.
    */
   public <A> A run(final DB<A> dba) throws SQLException {
-    final Connection c = pc.connect();
-    c.setAutoCommit(false);
-    try {
-      final A a = dba.run(c);
+    try (Connection c = pc.connect()) {
+      c.setAutoCommit(false);
+      final A a;
+      try {
+        a = dba.run(c);
+      } catch (RuntimeException | SQLException e) {
+        try {
+          c.rollback();
+        } catch (Exception re) {
+          e.addSuppressed(re);
+        }
+        throw e;
+      }
       terminal.run(c);
       return a;
-    } catch (SQLException e) {
-      c.rollback();
-      throw e;
-    }
-    finally {
-      c.close();
     }
   }
 }

From c45b0d64c66681d6779fa6ed021d263b2476b6f1 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 22:01:17 +0100
Subject: [PATCH 041/336] Fix IOFunctions#bracket

---
 core/src/main/java/fj/data/IOFunctions.java | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 755ce9fa..6aa5db12 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -5,6 +5,7 @@
 import static fj.Function.partialApply2;
 
 import java.io.BufferedReader;
+import java.io.Closeable;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -141,12 +142,8 @@ public static <A, B, C> IO<C> bracket(final IO<A> init, final F<A, IO<B>> fin, f
             @Override
             public C run() throws IOException {
                 final A a = init.run();
-                try {
+                try(Closeable finAsCloseable = fin.f(a)::run) {
                     return body.f(a).run();
-                } catch (final IOException e) {
-                    throw e;
-                } finally {
-                    fin.f(a);
                 }
             }
         };

From a069fa5e2ecdb8b7653bd1c40de0a1fb0a53a5a9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 22:08:58 +0100
Subject: [PATCH 042/336] Remove unused import statements

---
 core/src/main/java/fj/Class.java              |  1 -
 core/src/main/java/fj/F.java                  | 32 -------------------
 core/src/main/java/fj/F2.java                 | 19 -----------
 core/src/main/java/fj/F2W.java                |  7 ----
 core/src/main/java/fj/F3Functions.java        |  6 ----
 core/src/main/java/fj/F4Functions.java        |  3 --
 core/src/main/java/fj/F5Functions.java        |  3 --
 core/src/main/java/fj/F6Functions.java        |  3 --
 core/src/main/java/fj/F7Functions.java        |  3 --
 core/src/main/java/fj/F8Functions.java        |  3 --
 core/src/main/java/fj/TryEffect.java          |  4 ---
 core/src/main/java/fj/data/Enumerator.java    |  2 +-
 core/src/main/java/fj/data/IterableW.java     |  2 --
 core/src/main/java/fj/data/Iteratee.java      |  1 -
 core/src/main/java/fj/data/Java.java          |  3 --
 core/src/main/java/fj/data/Natural.java       |  2 +-
 core/src/main/java/fj/data/SafeIO.java        |  2 --
 core/src/main/java/fj/data/State.java         |  2 --
 .../main/java/fj/data/fingertrees/Empty.java  |  1 -
 .../main/java/fj/data/fingertrees/Node.java   |  1 -
 core/src/main/java/fj/data/hlist/HPre.java    |  1 -
 core/src/main/java/fj/data/vector/V.java      |  1 -
 .../main/java/fj/function/BigIntegers.java    |  1 -
 .../src/main/java/fj/function/Characters.java |  1 -
 core/src/main/java/fj/function/Doubles.java   |  1 -
 core/src/main/java/fj/function/Integers.java  |  2 +-
 core/src/main/java/fj/function/Longs.java     |  2 +-
 core/src/main/java/fj/function/Visitor.java   |  1 -
 core/src/main/java/fj/parser/Result.java      |  2 +-
 demo/src/main/java/fj/demo/Array_bind.java    |  1 -
 demo/src/main/java/fj/demo/ChequeWrite.java   |  1 -
 .../main/java/fj/demo/Comonad_example.java    |  1 -
 .../main/java/fj/demo/HList_foldRight.java    |  2 --
 demo/src/main/java/fj/demo/Primes2.java       |  2 +-
 demo/src/main/java/fj/demo/Set_map.java       |  1 -
 .../fj/demo/StateDemo_VendingMachine.java     |  1 -
 .../main/java/fj/demo/concurrent/Fibs.java    |  2 +-
 .../main/java/fj/demo/concurrent/Ping.java    |  1 -
 .../java/fj/demo/concurrent/PingPong.java     |  1 -
 .../main/java/fj/demo/concurrent/Pong.java    |  1 -
 .../java/fj/demo/concurrent/WordCount.java    |  1 -
 .../src/main/java/fj/demo/euler/Problem1.java |  1 -
 .../src/main/java/fj/demo/euler/Problem3.java |  2 --
 .../src/main/java/fj/demo/euler/Problem4.java |  1 -
 .../java/fj/demo/test/AdditionCommutes.java   |  1 -
 .../demo/test/AdditionCommutesParallel.java   |  2 --
 .../java/fj/demo/test/EqualsHashCode.java     |  3 --
 .../java/fj/demo/test/IntegerOverflow.java    |  1 -
 .../java/fj/demo/test/JavaLinkedList.java     |  1 -
 .../java/fj/demo/test/ListFunctorLaws.java    |  2 --
 .../fj/demo/test/OptionMonadFunctorLaw.java   |  2 --
 demo/src/main/java/fj/demo/test/Reflect.java  |  2 --
 .../fj/demo/test/StringBuilderReverse.java    |  2 --
 .../main/java/fj/demo/test/Triangulation.java |  1 -
 .../src/main/java/fj/test/Arbitrary.java      |  1 -
 quickcheck/src/main/java/fj/test/Bool.java    |  2 +-
 quickcheck/src/main/java/fj/test/Result.java  |  1 -
 .../src/main/java/fj/test/reflect/Check.java  |  1 -
 .../java/fj/test/reflect/CheckParams.java     |  1 -
 59 files changed, 8 insertions(+), 146 deletions(-)

diff --git a/core/src/main/java/fj/Class.java b/core/src/main/java/fj/Class.java
index e2630569..da214af1 100644
--- a/core/src/main/java/fj/Class.java
+++ b/core/src/main/java/fj/Class.java
@@ -2,7 +2,6 @@
 
 import fj.data.List;
 import static fj.data.List.unfold;
-import fj.data.Option;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
 import fj.data.Tree;
diff --git a/core/src/main/java/fj/F.java b/core/src/main/java/fj/F.java
index 2a0136bf..e2db316e 100644
--- a/core/src/main/java/fj/F.java
+++ b/core/src/main/java/fj/F.java
@@ -1,37 +1,5 @@
 package fj;
 
-import fj.control.parallel.Actor;
-import fj.control.parallel.Promise;
-import fj.control.parallel.Strategy;
-import fj.data.Array;
-import fj.data.Either;
-import fj.data.IterableW;
-import fj.data.List;
-import fj.data.NonEmptyList;
-import fj.data.Option;
-import fj.data.Set;
-import fj.data.Stream;
-import fj.data.Tree;
-import fj.data.TreeZipper;
-import fj.data.Validation;
-import fj.data.Zipper;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.PriorityQueue;
-import java.util.TreeSet;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.PriorityBlockingQueue;
-import java.util.concurrent.SynchronousQueue;
-
-import static fj.data.Option.some;
-import static fj.data.Stream.iterableStream;
-import static fj.data.Zipper.fromStream;
-
 /**
  * A transformation or function from <code>A</code> to <code>B</code>. This type can be represented
  * using the Java 7 closure syntax.
diff --git a/core/src/main/java/fj/F2.java b/core/src/main/java/fj/F2.java
index 1723927a..63555fd5 100644
--- a/core/src/main/java/fj/F2.java
+++ b/core/src/main/java/fj/F2.java
@@ -1,24 +1,5 @@
 package fj;
 
-import fj.control.parallel.Promise;
-import fj.data.Array;
-import fj.data.IterableW;
-import fj.data.List;
-import fj.data.NonEmptyList;
-import fj.data.Option;
-import fj.data.Set;
-import fj.data.Stream;
-import fj.data.Tree;
-import fj.data.TreeZipper;
-import fj.data.Zipper;
-
-import static fj.data.Tree.node;
-import static fj.P.p;
-import static fj.data.IterableW.wrap;
-import static fj.data.Set.iterableSet;
-import static fj.data.TreeZipper.treeZipper;
-import static fj.data.Zipper.zipper;
-
 /**
  * A transformation function of arity-2 from <code>A</code> and <code>B</code> to <code>C</code>.
  * This type can be represented using the Java 7 closure syntax.
diff --git a/core/src/main/java/fj/F2W.java b/core/src/main/java/fj/F2W.java
index 7a2f6e19..eb2fb590 100644
--- a/core/src/main/java/fj/F2W.java
+++ b/core/src/main/java/fj/F2W.java
@@ -3,13 +3,6 @@
 import fj.control.parallel.Promise;
 import fj.data.*;
 
-import static fj.P.p;
-import static fj.data.IterableW.wrap;
-import static fj.data.Set.iterableSet;
-import static fj.data.Tree.node;
-import static fj.data.TreeZipper.treeZipper;
-import static fj.data.Zipper.zipper;
-
 /**
  * Created by MarkPerry on 22/01/2015.
  */
diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
index a1e0b8f7..18e811d9 100644
--- a/core/src/main/java/fj/F3Functions.java
+++ b/core/src/main/java/fj/F3Functions.java
@@ -1,11 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try3;
-
-import static fj.data.Validation.fail;
-import static fj.data.Validation.success;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
index 04525167..cb353764 100644
--- a/core/src/main/java/fj/F4Functions.java
+++ b/core/src/main/java/fj/F4Functions.java
@@ -1,8 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try4;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
index d8dda4da..c39b228f 100644
--- a/core/src/main/java/fj/F5Functions.java
+++ b/core/src/main/java/fj/F5Functions.java
@@ -1,8 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try5;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
index 69ce270a..320b95f4 100644
--- a/core/src/main/java/fj/F6Functions.java
+++ b/core/src/main/java/fj/F6Functions.java
@@ -1,8 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try6;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
index 0f2f25ac..e583ba4b 100644
--- a/core/src/main/java/fj/F7Functions.java
+++ b/core/src/main/java/fj/F7Functions.java
@@ -1,8 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try7;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
index 5eafe1f3..071cb6bc 100644
--- a/core/src/main/java/fj/F8Functions.java
+++ b/core/src/main/java/fj/F8Functions.java
@@ -1,8 +1,5 @@
 package fj;
 
-import fj.data.Validation;
-import fj.function.Try8;
-
 /**
  * Created by MarkPerry on 6/04/2014.
  */
diff --git a/core/src/main/java/fj/TryEffect.java b/core/src/main/java/fj/TryEffect.java
index 90acaf06..cd1f75ab 100644
--- a/core/src/main/java/fj/TryEffect.java
+++ b/core/src/main/java/fj/TryEffect.java
@@ -1,12 +1,8 @@
 package fj;
 
-import fj.data.IO;
-import fj.data.IOFunctions;
 import fj.data.Validation;
 import fj.function.*;
 
-import java.io.IOException;
-
 /**
  * Created by mperry on 29/08/2014.
  */
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index cc143f33..14edff71 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -1,7 +1,7 @@
 package fj.data;
 
 import fj.F;
-import fj.F2;
+
 import static fj.Function.*;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
diff --git a/core/src/main/java/fj/data/IterableW.java b/core/src/main/java/fj/data/IterableW.java
index 9c701a98..9e36e710 100644
--- a/core/src/main/java/fj/data/IterableW.java
+++ b/core/src/main/java/fj/data/IterableW.java
@@ -5,8 +5,6 @@
 import fj.Equal;
 import fj.F;
 import fj.F2;
-import fj.F3;
-import fj.P1;
 import fj.P2;
 import static fj.Function.curry;
 import static fj.Function.identity;
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index 7b413293..5912ec1b 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -5,7 +5,6 @@
 import fj.F1Functions;
 import fj.Function;
 import fj.P;
-import fj.P1;
 import fj.P2;
 import fj.Unit;
 
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 29c5714c..e2f9adfd 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -4,9 +4,6 @@
 
 import static fj.P.p;
 
-import fj.function.Effect1;
-
-import static fj.data.List.list;
 import static fj.data.Option.some;
 
 import java.util.Arrays;
diff --git a/core/src/main/java/fj/data/Natural.java b/core/src/main/java/fj/data/Natural.java
index 25cd11d5..396aa39c 100644
--- a/core/src/main/java/fj/data/Natural.java
+++ b/core/src/main/java/fj/data/Natural.java
@@ -2,7 +2,7 @@
 
 import static fj.Bottom.error;
 import fj.F;
-import fj.F2;
+
 import static fj.Monoid.naturalAdditionMonoid;
 import static fj.Monoid.naturalMultiplicationMonoid;
 import static fj.Function.curry;
diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index 13bbbcc5..ef4c608c 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -1,7 +1,5 @@
 package fj.data;
 
-import java.io.IOException;
-
 /**
  * Created by MarkPerry on 3/07/2014.
  */
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 2d87234f..81146f95 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -2,8 +2,6 @@
 
 import fj.*;
 
-import java.util.*;
-
 import static fj.P.p;
 
 /**
diff --git a/core/src/main/java/fj/data/fingertrees/Empty.java b/core/src/main/java/fj/data/fingertrees/Empty.java
index 17ea5927..9f2b9bd2 100644
--- a/core/src/main/java/fj/data/fingertrees/Empty.java
+++ b/core/src/main/java/fj/data/fingertrees/Empty.java
@@ -1,7 +1,6 @@
 package fj.data.fingertrees;
 
 import fj.F;
-import fj.P;
 import fj.P2;
 import fj.P3;
 
diff --git a/core/src/main/java/fj/data/fingertrees/Node.java b/core/src/main/java/fj/data/fingertrees/Node.java
index 3e451766..d107c8d4 100644
--- a/core/src/main/java/fj/data/fingertrees/Node.java
+++ b/core/src/main/java/fj/data/fingertrees/Node.java
@@ -1,7 +1,6 @@
 package fj.data.fingertrees;
 
 import fj.F;
-import fj.F2;
 import fj.P2;
 import fj.P3;
 import fj.data.Option;
diff --git a/core/src/main/java/fj/data/hlist/HPre.java b/core/src/main/java/fj/data/hlist/HPre.java
index a37c3b78..6a2556de 100644
--- a/core/src/main/java/fj/data/hlist/HPre.java
+++ b/core/src/main/java/fj/data/hlist/HPre.java
@@ -1,6 +1,5 @@
 package fj.data.hlist;
 
-import fj.F;
 import fj.Show;
 
 /**
diff --git a/core/src/main/java/fj/data/vector/V.java b/core/src/main/java/fj/data/vector/V.java
index 84481d96..26a86462 100644
--- a/core/src/main/java/fj/data/vector/V.java
+++ b/core/src/main/java/fj/data/vector/V.java
@@ -7,7 +7,6 @@
 import fj.F5;
 import fj.P;
 import fj.P1;
-import fj.P2;
 
 /**
  * Functions across vectors.
diff --git a/core/src/main/java/fj/function/BigIntegers.java b/core/src/main/java/fj/function/BigIntegers.java
index b60d29f4..97f1a520 100644
--- a/core/src/main/java/fj/function/BigIntegers.java
+++ b/core/src/main/java/fj/function/BigIntegers.java
@@ -1,7 +1,6 @@
 package fj.function;
 
 import fj.F;
-import fj.F2;
 import fj.Monoid;
 import fj.data.List;
 import static fj.Function.curry;
diff --git a/core/src/main/java/fj/function/Characters.java b/core/src/main/java/fj/function/Characters.java
index 8aebde7b..9191bd5a 100644
--- a/core/src/main/java/fj/function/Characters.java
+++ b/core/src/main/java/fj/function/Characters.java
@@ -1,7 +1,6 @@
 package fj.function;
 
 import fj.F;
-import fj.F2;
 
 import static fj.Function.curry;
 
diff --git a/core/src/main/java/fj/function/Doubles.java b/core/src/main/java/fj/function/Doubles.java
index a15a4042..1a85a100 100644
--- a/core/src/main/java/fj/function/Doubles.java
+++ b/core/src/main/java/fj/function/Doubles.java
@@ -1,7 +1,6 @@
 package fj.function;
 
 import fj.F;
-import fj.F2;
 import fj.Monoid;
 import fj.data.List;
 import fj.data.Option;
diff --git a/core/src/main/java/fj/function/Integers.java b/core/src/main/java/fj/function/Integers.java
index 10fd3b15..c51359e4 100644
--- a/core/src/main/java/fj/function/Integers.java
+++ b/core/src/main/java/fj/function/Integers.java
@@ -1,7 +1,7 @@
 package fj.function;
 
 import fj.F;
-import fj.F2;
+
 import static fj.Function.curry;
 
 import fj.Monoid;
diff --git a/core/src/main/java/fj/function/Longs.java b/core/src/main/java/fj/function/Longs.java
index 89c2babd..a1bd60eb 100644
--- a/core/src/main/java/fj/function/Longs.java
+++ b/core/src/main/java/fj/function/Longs.java
@@ -1,7 +1,7 @@
 package fj.function;
 
 import fj.F;
-import fj.F2;
+
 import static fj.Function.curry;
 import static fj.Semigroup.longAdditionSemigroup;
 import static fj.Semigroup.longMultiplicationSemigroup;
diff --git a/core/src/main/java/fj/function/Visitor.java b/core/src/main/java/fj/function/Visitor.java
index ebd18c03..0f8c3846 100644
--- a/core/src/main/java/fj/function/Visitor.java
+++ b/core/src/main/java/fj/function/Visitor.java
@@ -3,7 +3,6 @@
 import fj.Equal;
 import fj.F;
 import fj.F0;
-import fj.F2;
 import fj.Function;
 import fj.Monoid;
 import fj.P1;
diff --git a/core/src/main/java/fj/parser/Result.java b/core/src/main/java/fj/parser/Result.java
index bcec7d8b..f450a054 100644
--- a/core/src/main/java/fj/parser/Result.java
+++ b/core/src/main/java/fj/parser/Result.java
@@ -1,7 +1,7 @@
 package fj.parser;
 
 import fj.F;
-import fj.F2;
+
 import static fj.Function.curry;
 
 import java.util.Iterator;
diff --git a/demo/src/main/java/fj/demo/Array_bind.java b/demo/src/main/java/fj/demo/Array_bind.java
index a0182dd1..6048ce62 100644
--- a/demo/src/main/java/fj/demo/Array_bind.java
+++ b/demo/src/main/java/fj/demo/Array_bind.java
@@ -1,6 +1,5 @@
 package fj.demo;
 
-import fj.F;
 import fj.data.Array;
 import static fj.data.Array.array;
 import static fj.Show.arrayShow;
diff --git a/demo/src/main/java/fj/demo/ChequeWrite.java b/demo/src/main/java/fj/demo/ChequeWrite.java
index 44ee2956..d2d07d3d 100644
--- a/demo/src/main/java/fj/demo/ChequeWrite.java
+++ b/demo/src/main/java/fj/demo/ChequeWrite.java
@@ -1,7 +1,6 @@
 package fj.demo;
 
 import fj.F;
-import fj.F2;
 import fj.P2;
 import fj.data.List;
 import fj.data.Option;
diff --git a/demo/src/main/java/fj/demo/Comonad_example.java b/demo/src/main/java/fj/demo/Comonad_example.java
index 70230e1d..9a64c34e 100644
--- a/demo/src/main/java/fj/demo/Comonad_example.java
+++ b/demo/src/main/java/fj/demo/Comonad_example.java
@@ -1,6 +1,5 @@
 package fj.demo;
 
-import fj.F;
 import fj.F1Functions;
 import fj.P;
 import static fj.data.List.asString;
diff --git a/demo/src/main/java/fj/demo/HList_foldRight.java b/demo/src/main/java/fj/demo/HList_foldRight.java
index 4f5ee3e1..51f6f4c2 100644
--- a/demo/src/main/java/fj/demo/HList_foldRight.java
+++ b/demo/src/main/java/fj/demo/HList_foldRight.java
@@ -4,8 +4,6 @@
 import static fj.Function.identity;
 import fj.P2;
 import fj.Unit;
-import static fj.Unit.unit;
-import static java.lang.System.out;
 
 import fj.data.hlist.HList;
 import static fj.data.hlist.HList.single;
diff --git a/demo/src/main/java/fj/demo/Primes2.java b/demo/src/main/java/fj/demo/Primes2.java
index 4a5b9dbd..96a852f3 100644
--- a/demo/src/main/java/fj/demo/Primes2.java
+++ b/demo/src/main/java/fj/demo/Primes2.java
@@ -1,7 +1,7 @@
 package fj.demo;
 
 import fj.F1Functions;
-import fj.P1;
+
 import static fj.data.Enumerator.naturalEnumerator;
 
 import fj.Show;
diff --git a/demo/src/main/java/fj/demo/Set_map.java b/demo/src/main/java/fj/demo/Set_map.java
index ff5428df..054fbc15 100644
--- a/demo/src/main/java/fj/demo/Set_map.java
+++ b/demo/src/main/java/fj/demo/Set_map.java
@@ -1,6 +1,5 @@
 package fj.demo;
 
-import fj.F;
 import fj.data.Set;
 import static fj.data.Set.empty;
 import fj.Ord;
diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index 3178e37b..167a08f5 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -1,6 +1,5 @@
 package fj.demo;
 
-import fj.F2;
 import fj.data.List;
 import fj.data.State;
 
diff --git a/demo/src/main/java/fj/demo/concurrent/Fibs.java b/demo/src/main/java/fj/demo/concurrent/Fibs.java
index b3aae799..5e95e597 100644
--- a/demo/src/main/java/fj/demo/concurrent/Fibs.java
+++ b/demo/src/main/java/fj/demo/concurrent/Fibs.java
@@ -1,7 +1,7 @@
 package fj.demo.concurrent;
 
 import static fj.Bottom.error;
-import fj.Effect;
+
 import fj.F;
 import fj.P;
 import fj.P2;
diff --git a/demo/src/main/java/fj/demo/concurrent/Ping.java b/demo/src/main/java/fj/demo/concurrent/Ping.java
index 82aad6b3..3ba934fb 100644
--- a/demo/src/main/java/fj/demo/concurrent/Ping.java
+++ b/demo/src/main/java/fj/demo/concurrent/Ping.java
@@ -1,6 +1,5 @@
 package fj.demo.concurrent;
 
-import fj.Effect;
 import fj.Unit;
 import fj.P1;
 import fj.control.parallel.Actor;
diff --git a/demo/src/main/java/fj/demo/concurrent/PingPong.java b/demo/src/main/java/fj/demo/concurrent/PingPong.java
index d6bddbbf..b0b09011 100644
--- a/demo/src/main/java/fj/demo/concurrent/PingPong.java
+++ b/demo/src/main/java/fj/demo/concurrent/PingPong.java
@@ -2,7 +2,6 @@
 
 import static fj.Bottom.error;
 import fj.Unit;
-import fj.Effect;
 import fj.control.parallel.Strategy;
 import fj.control.parallel.Actor;
 import fj.function.Effect1;
diff --git a/demo/src/main/java/fj/demo/concurrent/Pong.java b/demo/src/main/java/fj/demo/concurrent/Pong.java
index d85eda7e..b0f0ad57 100644
--- a/demo/src/main/java/fj/demo/concurrent/Pong.java
+++ b/demo/src/main/java/fj/demo/concurrent/Pong.java
@@ -1,6 +1,5 @@
 package fj.demo.concurrent;
 
-import fj.Effect;
 import fj.Unit;
 import fj.P1;
 import fj.control.parallel.Actor;
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index 67fef136..b4d3dae2 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -19,7 +19,6 @@
 import java.util.concurrent.ExecutorService;
 
 import fj.F;
-import fj.F2;
 import fj.Monoid;
 import fj.P;
 import fj.P1;
diff --git a/demo/src/main/java/fj/demo/euler/Problem1.java b/demo/src/main/java/fj/demo/euler/Problem1.java
index 82dc53c0..e20f9a97 100644
--- a/demo/src/main/java/fj/demo/euler/Problem1.java
+++ b/demo/src/main/java/fj/demo/euler/Problem1.java
@@ -1,6 +1,5 @@
 package fj.demo.euler;
 
-import fj.F;
 import fj.data.Stream;
 
 import static fj.data.List.range;
diff --git a/demo/src/main/java/fj/demo/euler/Problem3.java b/demo/src/main/java/fj/demo/euler/Problem3.java
index bde87126..e429e0e9 100644
--- a/demo/src/main/java/fj/demo/euler/Problem3.java
+++ b/demo/src/main/java/fj/demo/euler/Problem3.java
@@ -1,7 +1,5 @@
 package fj.demo.euler;
 
-import fj.F;
-import fj.P;
 import fj.P1;
 import static fj.data.Enumerator.naturalEnumerator;
 import fj.data.Natural;
diff --git a/demo/src/main/java/fj/demo/euler/Problem4.java b/demo/src/main/java/fj/demo/euler/Problem4.java
index f1947057..60c04d85 100644
--- a/demo/src/main/java/fj/demo/euler/Problem4.java
+++ b/demo/src/main/java/fj/demo/euler/Problem4.java
@@ -1,6 +1,5 @@
 package fj.demo.euler;
 
-import fj.F;
 import static fj.Function.flip;
 import fj.data.Stream;
 import static fj.data.Stream.iterate;
diff --git a/demo/src/main/java/fj/demo/test/AdditionCommutes.java b/demo/src/main/java/fj/demo/test/AdditionCommutes.java
index 8aea4f03..7b2a6571 100644
--- a/demo/src/main/java/fj/demo/test/AdditionCommutes.java
+++ b/demo/src/main/java/fj/demo/test/AdditionCommutes.java
@@ -1,6 +1,5 @@
 package fj.demo.test;
 
-import fj.F2;
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.CheckResult.summary;
 import fj.test.Property;
diff --git a/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java b/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java
index b1629c21..d61ffeb0 100644
--- a/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java
+++ b/demo/src/main/java/fj/demo/test/AdditionCommutesParallel.java
@@ -1,8 +1,6 @@
 package fj.demo.test;
 
-import fj.F2;
 import fj.P;
-import fj.P1;
 import fj.control.parallel.Strategy;
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.CheckResult.summary;
diff --git a/demo/src/main/java/fj/demo/test/EqualsHashCode.java b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
index 20a732a2..814f7112 100644
--- a/demo/src/main/java/fj/demo/test/EqualsHashCode.java
+++ b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
@@ -1,8 +1,5 @@
 package fj.demo.test;
 
-import fj.F;
-import fj.F2;
-import fj.F3;
 import static fj.Function.curry;
 import fj.test.Arbitrary;
 import static fj.test.Arbitrary.arbByte;
diff --git a/demo/src/main/java/fj/demo/test/IntegerOverflow.java b/demo/src/main/java/fj/demo/test/IntegerOverflow.java
index 155f8495..48b9d2dc 100644
--- a/demo/src/main/java/fj/demo/test/IntegerOverflow.java
+++ b/demo/src/main/java/fj/demo/test/IntegerOverflow.java
@@ -1,6 +1,5 @@
 package fj.demo.test;
 
-import fj.F2;
 import static fj.test.Arbitrary.arbIntegerBoundaries;
 import static fj.test.Bool.bool;
 import static fj.test.CheckResult.summary;
diff --git a/demo/src/main/java/fj/demo/test/JavaLinkedList.java b/demo/src/main/java/fj/demo/test/JavaLinkedList.java
index 0954c705..5ce11fba 100644
--- a/demo/src/main/java/fj/demo/test/JavaLinkedList.java
+++ b/demo/src/main/java/fj/demo/test/JavaLinkedList.java
@@ -1,6 +1,5 @@
 package fj.demo.test;
 
-import fj.F2;
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.Arbitrary.arbLinkedList;
 import static fj.test.CheckResult.summary;
diff --git a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
index e0c99f64..03095e80 100644
--- a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
+++ b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
@@ -1,7 +1,5 @@
 package fj.demo.test;
 
-import fj.F;
-import fj.F3;
 import fj.Function;
 import static fj.Function.compose;
 import fj.P2;
diff --git a/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java b/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
index 675c8eff..18d1b5d7 100644
--- a/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
+++ b/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
@@ -1,7 +1,5 @@
 package fj.demo.test;
 
-import fj.F;
-import fj.F2;
 import static fj.Function.andThen;
 import fj.data.Option;
 import static fj.Equal.optionEqual;
diff --git a/demo/src/main/java/fj/demo/test/Reflect.java b/demo/src/main/java/fj/demo/test/Reflect.java
index 79d013dc..d5ebfd36 100644
--- a/demo/src/main/java/fj/demo/test/Reflect.java
+++ b/demo/src/main/java/fj/demo/test/Reflect.java
@@ -2,8 +2,6 @@
 
 import static fj.Bottom.error;
 
-import fj.F;
-import fj.F2;
 import fj.P2;
 import fj.data.List;
 import static fj.data.List.list;
diff --git a/demo/src/main/java/fj/demo/test/StringBuilderReverse.java b/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
index 9338065b..b0897044 100644
--- a/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
+++ b/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
@@ -1,7 +1,5 @@
 package fj.demo.test;
 
-import fj.F;
-import fj.F2;
 import static fj.data.List.list;
 import static fj.Equal.stringBuilderEqual;
 import static fj.test.Arbitrary.arbCharacter;
diff --git a/demo/src/main/java/fj/demo/test/Triangulation.java b/demo/src/main/java/fj/demo/test/Triangulation.java
index 56d110f2..10de64ea 100644
--- a/demo/src/main/java/fj/demo/test/Triangulation.java
+++ b/demo/src/main/java/fj/demo/test/Triangulation.java
@@ -1,6 +1,5 @@
 package fj.demo.test;
 
-import fj.F;
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.CheckResult.summary;
 import fj.test.Property;
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 5222df9e..1e619f21 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -69,7 +69,6 @@
 import java.util.PriorityQueue;
 import java.util.Properties;
 import java.util.Stack;
-import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.Vector;
 import java.util.WeakHashMap;
diff --git a/quickcheck/src/main/java/fj/test/Bool.java b/quickcheck/src/main/java/fj/test/Bool.java
index deb072cf..18239fa6 100644
--- a/quickcheck/src/main/java/fj/test/Bool.java
+++ b/quickcheck/src/main/java/fj/test/Bool.java
@@ -1,7 +1,7 @@
 package fj.test;
 
 import fj.F0;
-import fj.P1;
+
 import static fj.test.Property.prop;
 
 /**
diff --git a/quickcheck/src/main/java/fj/test/Result.java b/quickcheck/src/main/java/fj/test/Result.java
index eb6b973b..40130542 100644
--- a/quickcheck/src/main/java/fj/test/Result.java
+++ b/quickcheck/src/main/java/fj/test/Result.java
@@ -1,7 +1,6 @@
 package fj.test;
 
 import fj.F;
-import fj.P1;
 import fj.data.List;
 import fj.data.Option;
 import static fj.data.Option.none;
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index 079dcb22..5b7dbbb3 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -1,6 +1,5 @@
 package fj.test.reflect;
 
-import static fj.Bottom.error;
 import fj.Class;
 import static fj.Class.clas;
 import fj.F;
diff --git a/quickcheck/src/main/java/fj/test/reflect/CheckParams.java b/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
index 725a7504..8c8445c1 100644
--- a/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
+++ b/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
@@ -1,6 +1,5 @@
 package fj.test.reflect;
 
-import fj.P1;
 import fj.test.Property;
 
 import java.lang.annotation.Documented;

From 316d1d48768ed6c6730843393f799451c7e5cd68 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 22:29:38 +0100
Subject: [PATCH 043/336] Use method reference (over lambda) whenever possible

---
 core/src/main/java/fj/Bottom.java             |   4 +-
 core/src/main/java/fj/Class.java              |   2 +-
 core/src/main/java/fj/Digit.java              |   8 +-
 core/src/main/java/fj/Effect.java             |   2 +-
 core/src/main/java/fj/Equal.java              |   4 +-
 core/src/main/java/fj/Function.java           |  24 +--
 core/src/main/java/fj/Hash.java               |   2 +-
 core/src/main/java/fj/Monoid.java             |   6 +-
 core/src/main/java/fj/Ord.java                |   6 +-
 core/src/main/java/fj/P.java                  |   2 +-
 core/src/main/java/fj/P1.java                 |  16 +-
 core/src/main/java/fj/P2.java                 |  14 +-
 core/src/main/java/fj/P3.java                 |   6 +-
 core/src/main/java/fj/P4.java                 |   8 +-
 core/src/main/java/fj/P5.java                 |  10 +-
 core/src/main/java/fj/P6.java                 |  36 +---
 core/src/main/java/fj/P7.java                 |  42 +---
 core/src/main/java/fj/P8.java                 |  48 +----
 core/src/main/java/fj/Semigroup.java          |  20 +-
 core/src/main/java/fj/Show.java               |   2 +-
 core/src/main/java/fj/control/Trampoline.java |  10 +-
 .../java/fj/control/parallel/Callables.java   |  16 +-
 .../java/fj/control/parallel/ParModule.java   |  18 +-
 .../java/fj/control/parallel/Promise.java     |   2 +-
 .../java/fj/control/parallel/Strategy.java    |   6 +-
 core/src/main/java/fj/data/Array.java         |   6 +-
 core/src/main/java/fj/data/Conversions.java   |  70 +++----
 core/src/main/java/fj/data/Either.java        |  26 +--
 core/src/main/java/fj/data/Enumerator.java    |   2 +-
 core/src/main/java/fj/data/HashMap.java       |   2 +-
 core/src/main/java/fj/data/IOFunctions.java   |  21 +-
 core/src/main/java/fj/data/IterableW.java     |  10 +-
 core/src/main/java/fj/data/Java.java          |  40 ++--
 core/src/main/java/fj/data/List.java          |  26 +--
 core/src/main/java/fj/data/Natural.java       |  12 +-
 core/src/main/java/fj/data/NonEmptyList.java  |   6 +-
 core/src/main/java/fj/data/Option.java        |  36 ++--
 core/src/main/java/fj/data/Set.java           |   8 +-
 core/src/main/java/fj/data/State.java         |   6 +-
 core/src/main/java/fj/data/Stream.java        |  42 ++--
 core/src/main/java/fj/data/Tree.java          |  10 +-
 core/src/main/java/fj/data/TreeMap.java       |   6 +-
 core/src/main/java/fj/data/TreeZipper.java    |  12 +-
 core/src/main/java/fj/data/Validation.java    |  36 ++--
 core/src/main/java/fj/data/Zipper.java        |   8 +-
 .../main/java/fj/data/fingertrees/Digit.java  |   4 +-
 .../java/fj/data/fingertrees/Measured.java    |   4 +-
 .../main/java/fj/data/optic/POptional.java    |   2 +-
 core/src/main/java/fj/data/optic/PPrism.java  |   2 +-
 core/src/main/java/fj/data/vector/V.java      |  10 +-
 core/src/main/java/fj/data/vector/V2.java     |  10 +-
 core/src/main/java/fj/data/vector/V3.java     |  14 +-
 core/src/main/java/fj/data/vector/V4.java     |  16 +-
 core/src/main/java/fj/data/vector/V5.java     |  18 +-
 core/src/main/java/fj/data/vector/V6.java     |  20 +-
 core/src/main/java/fj/data/vector/V7.java     |  22 +--
 core/src/main/java/fj/data/vector/V8.java     |  24 +--
 .../main/java/fj/function/BigIntegers.java    |  15 +-
 .../src/main/java/fj/function/Characters.java |  46 ++---
 core/src/main/java/fj/function/Doubles.java   |   4 +-
 core/src/main/java/fj/function/Integers.java  |   2 +-
 core/src/main/java/fj/function/Longs.java     |   2 +-
 core/src/main/java/fj/function/Strings.java   |   8 +-
 core/src/main/java/fj/parser/Parser.java      |  38 ++--
 core/src/main/java/fj/parser/Result.java      |   8 +-
 demo/src/main/java/fj/demo/IODemo.java        |   2 +-
 .../java/fj/demo/concurrent/WordCount.java    |   2 +-
 .../main/java/fj/demo/realworld/Chapter7.java |   4 +-
 .../java/fj/demo/test/EqualsHashCode.java     |   2 +-
 java8/src/main/java/fj/data/Java8.java        |  16 +-
 .../src/main/java/fj/test/Arbitrary.java      | 184 ++++--------------
 quickcheck/src/main/java/fj/test/Gen.java     |  18 +-
 .../src/main/java/fj/test/Property.java       |   6 +-
 quickcheck/src/main/java/fj/test/Result.java  |   2 +-
 quickcheck/src/main/java/fj/test/Shrink.java  |  30 +--
 .../src/main/java/fj/test/reflect/Check.java  |   6 +-
 76 files changed, 514 insertions(+), 726 deletions(-)

diff --git a/core/src/main/java/fj/Bottom.java b/core/src/main/java/fj/Bottom.java
index 0f828102..a70629f1 100644
--- a/core/src/main/java/fj/Bottom.java
+++ b/core/src/main/java/fj/Bottom.java
@@ -83,7 +83,7 @@ public static <A> Error decons(final java.lang.Class<A> c) {
    * @return A function that returns the <code>toString</code> for a throwable.
    */
   public static <T extends Throwable> F<T, String> eToString() {
-    return t -> t.toString();
+    return Throwable::toString;
   }
 
   /**
@@ -92,6 +92,6 @@ public static <T extends Throwable> F<T, String> eToString() {
    * @return A function that returns the <code>getMessage</code> for a throwable.
    */
   public static <T extends Throwable> F<T, String> eMessage() {
-    return t -> t.getMessage();
+    return Throwable::getMessage;
   }
 }
diff --git a/core/src/main/java/fj/Class.java b/core/src/main/java/fj/Class.java
index da214af1..d34aedb7 100644
--- a/core/src/main/java/fj/Class.java
+++ b/core/src/main/java/fj/Class.java
@@ -45,7 +45,7 @@ public java.lang.Class<? super T> _2() {
                     };
                 return some(p);
               }
-            }, c).map(c1 -> clas(c1));
+            }, c).map(Class::clas);
   }
 
   /**
diff --git a/core/src/main/java/fj/Digit.java b/core/src/main/java/fj/Digit.java
index ba3c2245..7213e278 100644
--- a/core/src/main/java/fj/Digit.java
+++ b/core/src/main/java/fj/Digit.java
@@ -176,20 +176,20 @@ public static Option<Digit> fromChar(final char c) {
   /**
    * First-class conversion from digit to a long.
    */
-  public static final F<Digit, Long> toLong = d -> d.toLong();
+  public static final F<Digit, Long> toLong = Digit::toLong;
 
   /**
    * First-class conversion from a long to a digit.
    */
-  public static final F<Long, Digit> fromLong = i -> fromLong(i);
+  public static final F<Long, Digit> fromLong = Digit::fromLong;
 
   /**
    * First-class conversion from a digit to a character.
    */
-  public static final F<Digit, Character> toChar = d -> d.toChar();
+  public static final F<Digit, Character> toChar = Digit::toChar;
 
   /**
    * First-class conversion from a character to a digit.
    */
-  public static final F<Character, Option<Digit>> fromChar = c -> fromChar(c);
+  public static final F<Character, Option<Digit>> fromChar = Digit::fromChar;
 }
diff --git a/core/src/main/java/fj/Effect.java b/core/src/main/java/fj/Effect.java
index 6e5e7b7f..80680cac 100644
--- a/core/src/main/java/fj/Effect.java
+++ b/core/src/main/java/fj/Effect.java
@@ -100,7 +100,7 @@ public static <A, B> Effect1<B> contramap(Effect1<A> e1, final F<B, A> f) {
   }
   
   public static <A> Effect1<A> lazy(final F<A, Unit> f) {
-    return a -> f.f(a);
+    return f::f;
 
   }
 
diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 27973afc..f503d096 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -55,7 +55,7 @@ public boolean notEq(final A a1, final A a2) {
    * @return A function that returns <code>true</code> if the two given arguments are equal.
    */
   public F2<A, A, Boolean> eq() {
-    return (a, a1) -> eq(a, a1);
+    return this::eq;
   }
 
   /**
@@ -96,7 +96,7 @@ public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
    *         equality.
    */
   public static <A> Equal<A> anyEqual() {
-    return equal(a1 -> a2 -> a1.equals(a2));
+    return equal(a1 -> a1::equals);
   }
 
   /**
diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index b3b96870..8d832798 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -89,7 +89,7 @@ public static <A> F<A, A> identity() {
    * @return A function that given an argument, returns a function that ignores its argument.
    */
   public static <A, B> F<B, F<A, B>> constant() {
-    return b -> constant(b);
+    return Function::constant;
   }
 
   /**
@@ -109,7 +109,7 @@ public static <A, B> F<A, B> constant(final B b) {
    * @return A co- and contravariant function that invokes f on its argument.
    */
   public static <A, B> F<A, B> vary(final F<? super A, ? extends B> f) {
-    return a -> f.f(a);
+    return f::f;
   }
 
   /**
@@ -118,7 +118,7 @@ public static <A, B> F<A, B> vary(final F<? super A, ? extends B> f) {
    * @return A function that varies and covaries a function.
    */
   public static <C, A extends C, B, D extends B> F<F<C, D>, F<A, B>> vary() {
-    return f -> Function.<A, B>vary(f);
+    return Function::<A, B>vary;
   }
 
   /**
@@ -127,7 +127,7 @@ public static <C, A extends C, B, D extends B> F<F<C, D>, F<A, B>> vary() {
    * @return A function that takes a function and flips its arguments.
    */
   public static <A, B, C> F<F<A, F<B, C>>, F<B, F<A, C>>> flip() {
-    return f -> flip(f);
+    return Function::flip;
   }
 
   /**
@@ -156,7 +156,7 @@ public static <A, B, C> F2<B, A, C> flip(final F2<A, B, C> f) {
    * @return A function that flips the arguments of a given function.
    */
   public static <A, B, C> F<F2<A, B, C>, F2<B, A, C>> flip2() {
-    return f -> flip(f);
+    return Function::flip;
   }
 
   /**
@@ -198,7 +198,7 @@ public static <A, B, C> F<B, C> curry(final F2<A, B, C> f, final A a) {
    * @return An uncurried function.
    */
   public static <A, B, C> F<F<A, F<B, C>>, F2<A, B, C>> uncurryF2() {
-    return f -> uncurryF2(f);
+    return Function::uncurryF2;
   }
 
   /**
@@ -250,7 +250,7 @@ public static <A, B, C, D> F<C, D> curry(final F3<A, B, C, D> f, final A a, fina
    * @return An uncurried function.
    */
   public static <A, B, C, D> F<F<A, F<B, F<C, D>>>, F3<A, B, C, D>> uncurryF3() {
-    return f -> uncurryF3(f);
+    return Function::uncurryF3;
   }
 
   /**
@@ -315,7 +315,7 @@ public static <A, B, C, D, E> F<D, E> curry(final F4<A, B, C, D, E> f, final A a
    * @return An uncurried function.
    */
   public static <A, B, C, D, E> F<F<A, F<B, F<C, F<D, E>>>>, F4<A, B, C, D, E>> uncurryF4() {
-    return f -> uncurryF4(f);
+    return Function::uncurryF4;
   }
 
   /**
@@ -396,7 +396,7 @@ public static <A, B, C, D, E> F4<A, B, C, D, E> uncurryF4(final F<A, F<B, F<C, F
    * @return An uncurried function.
    */
   public static <A, B, C, D, E, F$> F<F<A, F<B, F<C, F<D, F<E, F$>>>>>, F5<A, B, C, D, E, F$>> uncurryF5() {
-    return f -> uncurryF5(f);
+    return Function::uncurryF5;
   }
 
   /**
@@ -425,7 +425,7 @@ public static <A, B, C, D, E> F4<A, B, C, D, E> uncurryF4(final F<A, F<B, F<C, F
    * @return An uncurried function.
    */
   public static <A, B, C, D, E, F$, G> F<F<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>>, F6<A, B, C, D, E, F$, G>> uncurryF6() {
-    return f -> uncurryF6(f);
+    return Function::uncurryF6;
   }
 
   /**
@@ -543,7 +543,7 @@ public static <A, B, C, D, E> F4<A, B, C, D, E> uncurryF4(final F<A, F<B, F<C, F
    * @return An uncurried function.
    */
   public static <A, B, C, D, E, F$, G, H> F<F<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>>, F7<A, B, C, D, E, F$, G, H>> uncurryF7() {
-    return f -> uncurryF7(f);
+    return Function::uncurryF7;
   }
 
   /**
@@ -682,7 +682,7 @@ public static <A, B, C, D, E> F4<A, B, C, D, E> uncurryF4(final F<A, F<B, F<C, F
    * @return An uncurried function.
    */
   public static <A, B, C, D, E, F$, G, H, I> F<F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>>, F8<A, B, C, D, E, F$, G, H, I>> uncurryF8() {
-    return f -> uncurryF8(f);
+    return Function::uncurryF8;
   }
 
   /**
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 61c5e1cd..acb2a62c 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -62,7 +62,7 @@ public static <A> Hash<A> hash(final F<A, Integer> f) {
    * @return A hash that uses {@link Object#hashCode()}.
    */
   public static <A> Hash<A> anyHash() {
-    return hash(a -> a.hashCode());
+    return hash(Object::hashCode);
   }
 
   /**
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index a85a4712..be5215bb 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -156,7 +156,7 @@ public A sumLeft(final Stream<A> as) {
    * @return a function that sums the given values with left-fold.
    */
   public F<List<A>, A> sumLeft() {
-    return as -> sumLeft(as);
+    return this::sumLeft;
   }
 
   /**
@@ -165,7 +165,7 @@ public F<List<A>, A> sumLeft() {
    * @return a function that sums the given values with right-fold.
    */
   public F<List<A>, A> sumRight() {
-    return as -> sumRight(as);
+    return this::sumRight;
   }
 
   /**
@@ -174,7 +174,7 @@ public F<List<A>, A> sumRight() {
    * @return a function that sums the given values with left-fold.
    */
   public F<Stream<A>, A> sumLeftS() {
-    return as -> sumLeft(as);
+    return this::sumLeft;
   }
 
   /**
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 780f5edf..57d7e389 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -150,12 +150,12 @@ public A min(final A a1, final A a2) {
   /**
    * A function that returns the greater of its two arguments.
    */
-  public final F<A, F<A, A>> max = curry((a, a1) -> max(a, a1));
+  public final F<A, F<A, A>> max = curry(this::max);
 
   /**
    * A function that returns the lesser of its two arguments.
    */
-  public final F<A, F<A, A>> min = curry((a, a1) -> min(a, a1));
+  public final F<A, F<A, A>> min = curry(this::min);
 
   public Ord<A> reverse() { return ord(Function.flip(f)); }
 
@@ -428,7 +428,7 @@ public static <A> Ord<Array<A>> arrayOrd(final Ord<A> oa) {
    * @return An order instance for the {@link Set} type.
    */
   public static <A> Ord<Set<A>> setOrd(final Ord<A> oa) {
-    return streamOrd(oa).contramap(as -> as.toStream());
+    return streamOrd(oa).contramap(Set::toStream);
   }
 
   /**
diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index 2826b6b0..1ff82475 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -18,7 +18,7 @@ private P() {
    * @return A function that puts an element in a product-1.
    */
   public static <A> F<A, P1<A>> p1() {
-    return a -> p(a);
+    return P::p;
   }
 
   /**
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 0cb92a89..796daf22 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -33,7 +33,7 @@ public final A f() {
      * @return A function that returns the first element of a product.
      */
     public static <A> F<P1<A>, A> __1() {
-        return p -> p._1();
+        return P1::_1;
     }
 
     /**
@@ -147,7 +147,7 @@ public static <A> P1<List<A>> sequence(final List<P1<A>> as) {
      * @return A function from a List of P1s to a single P1 of a List.
      */
     public static <A> F<List<P1<A>>, P1<List<A>>> sequenceList() {
-        return as -> sequence(as);
+        return P1::sequence;
     }
 
     /**
@@ -164,7 +164,7 @@ public static <A> P1<Stream<A>> sequence(final Stream<P1<A>> as) {
 	 * Turns an optional P1 into a lazy option.
 	 */
 	public static <A> P1<Option<A>> sequence(final Option<P1<A>> o) {
-		return P.lazy(() -> o.map(p -> p._1()));
+		return P.lazy(() -> o.map(P1::_1));
 	}
 
     /**
@@ -184,7 +184,7 @@ public static <A> P1<Array<A>> sequence(final Array<P1<A>> as) {
      * @return A List of P1<B>
      */
     public <B> List<P1<B>> traverseList(final F<A, List<B>>  f){
-        return f.f(_1()).map(b -> P.p(b));
+        return f.f(_1()).map(P::p);
     }
 
     /**
@@ -194,7 +194,7 @@ public <B> List<P1<B>> traverseList(final F<A, List<B>>  f){
      * @return An Either of  P1<B>
      */
     public <B, X> Either<X, P1<B>> traverseEither(final F<A, Either<X, B>>  f){
-        return f.f(_1()).right().map(b -> P.p(b));
+        return f.f(_1()).right().map(P::p);
     }
 
     /**
@@ -204,7 +204,7 @@ public <B, X> Either<X, P1<B>> traverseEither(final F<A, Either<X, B>>  f){
      * @return An Option of  P1<B>
      */
     public <B> Option<P1<B>> traverseOption(final F<A, Option<B>>  f){
-        return f.f(_1()).map(b -> P.p(b));
+        return f.f(_1()).map(P::p);
     }
 
     /**
@@ -214,7 +214,7 @@ public <B> Option<P1<B>> traverseOption(final F<A, Option<B>>  f){
      * @return An Validation  of P1<B>
      */
     public <B, E> Validation<E, P1<B>> traverseValidation(final F<A, Validation<E, B>> f){
-        return f.f(_1()).map(b -> P.p(b));
+        return f.f(_1()).map(P::p);
     }
 
     /**
@@ -224,7 +224,7 @@ public <B, E> Validation<E, P1<B>> traverseValidation(final F<A, Validation<E, B
      * @return An Stream of  P1<B>
      */
     public <B> Stream<P1<B>> traverseStream(final F<A, Stream<B>>  f){
-        return f.f(_1()).map(b -> P.p(b));
+        return f.f(_1()).map(P::p);
     }
 
     /**
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index 3283f344..d564df35 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -42,7 +42,7 @@ public int hashCode() {
    * @return A new product-2 with the elements swapped.
    */
   public final P2<B, A> swap() {
-      return P.lazy(() -> P2.this._2(), () -> P2.this._1());
+      return P.lazy(P2.this::_2, P2.this::_1);
   }
 
   /**
@@ -53,7 +53,7 @@ public final P2<B, A> swap() {
    */
   public final <X> P2<X, B> map1(final F<A, X> f) {
       P2<A, B> self = this;
-      return P.lazy(() -> f.f(self._1()), () -> self._2());
+      return P.lazy(() -> f.f(self._1()), self::_2);
   }
 
   /**
@@ -63,7 +63,7 @@ public final <X> P2<X, B> map1(final F<A, X> f) {
    * @return A product with the given function applied.
    */
   public final <X> P2<A, X> map2(final F<B, X> f) {
-      return P.lazy(() -> P2.this._1(), () -> f.f(P2.this._2()));
+      return P.lazy(P2.this::_1, () -> f.f(P2.this._2()));
   }
 
 
@@ -90,7 +90,7 @@ public final <C, D> P2<C, D> split(final F<A, C> f, final F<B, D> g) {
    */
   public final <C> P2<C, B> cobind(final F<P2<A, B>, C> k) {
       P2<A, B> self = this;
-      return P.lazy(() -> k.f(self), () -> self._2());
+      return P.lazy(() -> k.f(self), self::_2);
   }
 
   /**
@@ -258,7 +258,7 @@ public static <A, B> P2<B, B> map(final F<A, B> f, final P2<A, A> p) {
    * @return A curried form of {@link #swap()}.
    */
   public static <A, B> F<P2<A, B>, P2<B, A>> swap_() {
-    return p -> p.swap();
+    return P2::swap;
   }
 
   /**
@@ -267,7 +267,7 @@ public static <A, B> F<P2<A, B>, P2<B, A>> swap_() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B> F<P2<A, B>, A> __1() {
-    return p -> p._1();
+    return P2::_1;
   }
 
   /**
@@ -276,7 +276,7 @@ public static <A, B> F<P2<A, B>, A> __1() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B> F<P2<A, B>, B> __2() {
-    return p -> p._2();
+    return P2::_2;
   }
 
   /**
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index 9f473f56..8760562b 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -152,7 +152,7 @@ public C _3() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C> F<P3<A, B, C>, A> __1() {
-    return p -> p._1();
+    return P3::_1;
   }
 
   /**
@@ -161,7 +161,7 @@ public static <A, B, C> F<P3<A, B, C>, A> __1() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C> F<P3<A, B, C>, B> __2() {
-    return p -> p._2();
+    return P3::_2;
   }
 
   /**
@@ -170,7 +170,7 @@ public static <A, B, C> F<P3<A, B, C>, B> __2() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C> F<P3<A, B, C>, C> __3() {
-    return p -> p._3();
+    return P3::_3;
   }
 
     @Override
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index 7ba55b5d..7f71943e 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -212,7 +212,7 @@ public D _4() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D> F<P4<A, B, C, D>, A> __1() {
-    return p -> p._1();
+    return P4::_1;
   }
 
   /**
@@ -221,7 +221,7 @@ public static <A, B, C, D> F<P4<A, B, C, D>, A> __1() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D> F<P4<A, B, C, D>, B> __2() {
-    return p -> p._2();
+    return P4::_2;
   }
 
   /**
@@ -230,7 +230,7 @@ public static <A, B, C, D> F<P4<A, B, C, D>, B> __2() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D> F<P4<A, B, C, D>, C> __3() {
-    return p -> p._3();
+    return P4::_3;
   }
 
   /**
@@ -239,7 +239,7 @@ public static <A, B, C, D> F<P4<A, B, C, D>, C> __3() {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D> F<P4<A, B, C, D>, D> __4() {
-    return p -> p._4();
+    return P4::_4;
   }
 
   @Override
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 6059e22a..57199302 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -278,7 +278,7 @@ public E _5() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E> F<P5<A, B, C, D, E>, A> __1() {
-    return p -> p._1();
+    return P5::_1;
   }
 
   /**
@@ -287,7 +287,7 @@ public static <A, B, C, D, E> F<P5<A, B, C, D, E>, A> __1() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E> F<P5<A, B, C, D, E>, B> __2() {
-    return p -> p._2();
+    return P5::_2;
   }
 
   /**
@@ -296,7 +296,7 @@ public static <A, B, C, D, E> F<P5<A, B, C, D, E>, B> __2() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E> F<P5<A, B, C, D, E>, C> __3() {
-    return p -> p._3();
+    return P5::_3;
   }
 
   /**
@@ -305,7 +305,7 @@ public static <A, B, C, D, E> F<P5<A, B, C, D, E>, C> __3() {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E> F<P5<A, B, C, D, E>, D> __4() {
-    return p -> p._4();
+    return P5::_4;
   }
 
   /**
@@ -314,7 +314,7 @@ public static <A, B, C, D, E> F<P5<A, B, C, D, E>, D> __4() {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E> F<P5<A, B, C, D, E>, E> __5() {
-    return p -> p._5();
+    return P5::_5;
   }
 
   @Override
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index c2983298..d1f32b87 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -355,11 +355,7 @@ public F _6() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, A> __1() {
-    return new fj.F<P6<A, B, C, D, E, F$>, A>() {
-      public A f(final P6<A, B, C, D, E, F$> p) {
-        return p._1();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_1;
   }
 
   /**
@@ -368,11 +364,7 @@ public A f(final P6<A, B, C, D, E, F$> p) {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, B> __2() {
-    return new fj.F<P6<A, B, C, D, E, F$>, B>() {
-      public B f(final P6<A, B, C, D, E, F$> p) {
-        return p._2();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_2;
   }
 
   /**
@@ -381,11 +373,7 @@ public B f(final P6<A, B, C, D, E, F$> p) {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, C> __3() {
-    return new fj.F<P6<A, B, C, D, E, F$>, C>() {
-      public C f(final P6<A, B, C, D, E, F$> p) {
-        return p._3();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_3;
   }
 
   /**
@@ -394,11 +382,7 @@ public C f(final P6<A, B, C, D, E, F$> p) {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, D> __4() {
-    return new fj.F<P6<A, B, C, D, E, F$>, D>() {
-      public D f(final P6<A, B, C, D, E, F$> p) {
-        return p._4();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_4;
   }
 
   /**
@@ -407,11 +391,7 @@ public D f(final P6<A, B, C, D, E, F$> p) {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, E> __5() {
-    return new fj.F<P6<A, B, C, D, E, F$>, E>() {
-      public E f(final P6<A, B, C, D, E, F$> p) {
-        return p._5();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_5;
   }
 
   /**
@@ -420,11 +400,7 @@ public E f(final P6<A, B, C, D, E, F$> p) {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, F$> __6() {
-    return new fj.F<P6<A, B, C, D, E, F$>, F$>() {
-      public F$ f(final P6<A, B, C, D, E, F$> p) {
-        return p._6();
-      }
-    };
+    return P6<A, B, C, D, E, F$>::_6;
   }
 
     @Override
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index 478e3d87..e81a2480 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -437,11 +437,7 @@ public G _7() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, A> __1() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, A>() {
-      public A f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._1();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_1;
   }
 
   /**
@@ -450,11 +446,7 @@ public A f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, B> __2() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, B>() {
-      public B f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._2();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_2;
   }
 
   /**
@@ -463,11 +455,7 @@ public B f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, C> __3() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, C>() {
-      public C f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._3();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_3;
   }
 
   /**
@@ -476,11 +464,7 @@ public C f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, D> __4() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, D>() {
-      public D f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._4();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_4;
   }
 
   /**
@@ -489,11 +473,7 @@ public D f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, E> __5() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, E>() {
-      public E f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._5();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_5;
   }
 
   /**
@@ -502,11 +482,7 @@ public E f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, F$> __6() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, F$>() {
-      public F$ f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._6();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_6;
   }
 
   /**
@@ -515,11 +491,7 @@ public E f(final P7<A, B, C, D, E, F$, G> p) {
    * @return A function that returns the seventh element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, G> __7() {
-    return new fj.F<P7<A, B, C, D, E, F$, G>, G>() {
-      public G f(final P7<A, B, C, D, E, F$, G> p) {
-        return p._7();
-      }
-    };
+    return P7<A, B, C, D, E, F$, G>::_7;
   }
 
   @Override
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index 62fef46e..982dca58 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -530,11 +530,7 @@ public H _8() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, A> __1() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, A>() {
-      public A f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._1();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_1;
   }
 
   /**
@@ -543,11 +539,7 @@ public A f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, B> __2() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, B>() {
-      public B f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._2();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_2;
   }
 
   /**
@@ -556,11 +548,7 @@ public B f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, C> __3() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, C>() {
-      public C f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._3();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_3;
   }
 
   /**
@@ -569,11 +557,7 @@ public C f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, D> __4() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, D>() {
-      public D f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._4();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_4;
   }
 
   /**
@@ -582,11 +566,7 @@ public D f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, E> __5() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, E>() {
-      public E f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._5();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_5;
   }
 
   /**
@@ -595,11 +575,7 @@ public E f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, F$> __6() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, F$>() {
-      public F$ f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._6();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_6;
   }
 
   /**
@@ -608,11 +584,7 @@ public E f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the seventh element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, G> __7() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, G>() {
-      public G f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._7();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_7;
   }
 
   /**
@@ -621,11 +593,7 @@ public G f(final P8<A, B, C, D, E, F$, G, H> p) {
    * @return A function that returns the eighth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, H> __8() {
-    return new fj.F<P8<A, B, C, D, E, F$, G, H>, H>() {
-      public H f(final P8<A, B, C, D, E, F$, G, H> p) {
-        return p._8();
-      }
-    };
+    return P8<A, B, C, D, E, F$, G, H>::_8;
   }
 
   @Override
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 6e091d7f..e7cd4c35 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -150,13 +150,13 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
    * A semigroup that adds big integers.
    */
   public static final Semigroup<BigInteger> bigintAdditionSemigroup =
-      semigroup((i1, i2) -> i1.add(i2));
+      semigroup(BigInteger::add);
 
   /**
    * A semigroup that multiplies big integers.
    */
   public static final Semigroup<BigInteger> bigintMultiplicationSemigroup =
-      semigroup((i1, i2) -> i1.multiply(i2));
+      semigroup(BigInteger::multiply);
 
   /**
    * A semigroup that yields the maximum of big integers.
@@ -172,13 +172,13 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
    * A semigroup that adds big decimals.
    */
   public static final Semigroup<BigDecimal> bigdecimalAdditionSemigroup =
-      semigroup((i1, i2) -> i1.add(i2));
+      semigroup(BigDecimal::add);
 
   /**
    * A semigroup that multiplies big decimals.
    */
   public static final Semigroup<BigDecimal> bigdecimalMultiplicationSemigroup =
-      semigroup((i1, i2) -> i1.multiply(i2));
+      semigroup(BigDecimal::multiply);
 
   /**
    * A semigroup that yields the maximum of big decimals.
@@ -194,13 +194,13 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
    * A semigroup that multiplies natural numbers.
    */
   public static final Semigroup<Natural> naturalMultiplicationSemigroup =
-      semigroup((n1, n2) -> n1.multiply(n2));
+      semigroup(Natural::multiply);
 
   /**
    * A semigroup that multiplies natural numbers.
    */
   public static final Semigroup<Natural> naturalAdditionSemigroup =
-      semigroup((n1, n2) -> n1.add(n2));
+      semigroup(Natural::add);
 
   /**
    * A semigroup that yields the maximum of natural numbers.
@@ -294,7 +294,7 @@ public static <A, B> Semigroup<F<A, B>> functionSemigroup(final Semigroup<B> sb)
    * @return A semigroup for lists.
    */
   public static <A> Semigroup<List<A>> listSemigroup() {
-    return semigroup((a1, a2) -> a1.append(a2));
+    return semigroup(List::append);
   }
 
   /**
@@ -303,7 +303,7 @@ public static <A> Semigroup<List<A>> listSemigroup() {
    * @return A semigroup for non-empty lists.
    */
   public static <A> Semigroup<NonEmptyList<A>> nonEmptyListSemigroup() {
-    return semigroup((a1, a2) -> a1.append(a2));
+    return semigroup(NonEmptyList::append);
   }
 
   /**
@@ -347,7 +347,7 @@ public static <A> Semigroup<Stream<A>> streamSemigroup() {
    * @return A semigroup for arrays.
    */
   public static <A> Semigroup<Array<A>> arraySemigroup() {
-    return semigroup((a1, a2) -> a1.append(a2));
+    return semigroup(Array::append);
   }
 
   /**
@@ -389,7 +389,7 @@ public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
    * @return a semigroup for sets.
    */
   public static <A> Semigroup<Set<A>> setSemigroup() {
-    return semigroup((a, b) -> a.union(b));
+    return semigroup(Set::union);
   }
 
 }
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 7e832c6c..5e6fd8b0 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -79,7 +79,7 @@ public String showS(final A a) {
    * @return the transformation equivalent to this show.
    */
   public F<A, String> showS_() {
-    return a -> showS(a);
+    return this::showS;
   }
 
   /**
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 49b6bb61..140deeaa 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -57,7 +57,7 @@ public Either<P1<Trampoline<A>>, A> resume() {
           // WARNING: In JDK 8, update 25 (current version) the following code is a
           // workaround for an internal JDK compiler error, likely due to
           // https:bugs.openjdk.java.net/browse/JDK-8062253.
-          F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(o1 -> cont.f(o1), t -> t._1().bind(cont));
+          F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
           F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
           return ot.fold(f, g);
         });
@@ -117,7 +117,7 @@ protected static <A, B> Codense<B> codense(final Normal<A> a, final F<A, Trampol
    * @return The first-class version of `pure`.
    */
   public static <A> F<A, Trampoline<A>> pure() {
-    return a -> pure(a);
+    return Trampoline::pure;
   }
 
   /**
@@ -144,7 +144,7 @@ public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
    * @return The first-class version of `suspend`.
    */
   public static <A> F<P1<Trampoline<A>>, Trampoline<A>> suspend_() {
-    return trampolineP1 -> suspend(trampolineP1);
+    return Trampoline::suspend;
   }
 
   protected abstract <R> R fold(final F<Normal<A>, R> n, final F<Codense<A>, R> gs);
@@ -185,7 +185,7 @@ public static <A, B> F<F<A, B>, F<Trampoline<A>, Trampoline<B>>> map_() {
    * @return The first-class version of `resume`.
    */
   public static <A> F<Trampoline<A>, Either<P1<Trampoline<A>>, A>> resume_() {
-    return aTrampoline -> aTrampoline.resume();
+    return Trampoline::resume;
   }
 
   /**
@@ -221,7 +221,7 @@ public A run() {
    * @return A new Trampoline after applying the given function through this Trampoline.
    */
   public final <B> Trampoline<B> apply(final Trampoline<F<A, B>> lf) {
-    return lf.bind(f -> map(f));
+    return lf.bind(this::map);
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Callables.java b/core/src/main/java/fj/control/parallel/Callables.java
index aeb9a312..40c8e746 100644
--- a/core/src/main/java/fj/control/parallel/Callables.java
+++ b/core/src/main/java/fj/control/parallel/Callables.java
@@ -51,7 +51,7 @@ public static <A> Callable<A> callable(final Exception e) {
    * @return A function from a value to a Callable that completely preserves that value.
    */
   public static <A> F<A, Callable<A>> callable() {
-    return a -> callable(a);
+    return Callables::callable;
   }
 
   /**
@@ -72,7 +72,7 @@ public static <A, B> F<A, Callable<B>> callable(final F<A, B> f) {
    * @return A transformation from a function to the equivalent Callable-valued function.
    */
   public static <A, B> F<F<A, B>, F<A, Callable<B>>> arrow() {
-    return f -> callable(f);
+    return Callables::callable;
   }
 
   /**
@@ -156,7 +156,7 @@ public static <A> Callable<List<A>> sequence(final List<Callable<A>> as) {
    * @return A function from a List of Callables to a single Callable of a List.
    */
   public static <A> F<List<Callable<A>>, Callable<List<A>>> sequence_() {
-    return as -> sequence(as);
+    return Callables::sequence;
   }
 
   /**
@@ -181,7 +181,7 @@ public static <A> P1<Option<A>> option(final Callable<A> a) {
    * @return a function that turns a Callable into an optional value.
    */
   public static <A> F<Callable<A>, P1<Option<A>>> option() {
-    return a -> option(a);
+    return Callables::option;
   }
 
   /**
@@ -206,7 +206,7 @@ public static <A> P1<Either<Exception, A>> either(final Callable<A> a) {
    * @return a function that turns a Callable into an Either.
    */
   public static <A> F<Callable<A>, P1<Either<Exception, A>>> either() {
-    return a -> either(a);
+    return Callables::either;
   }
 
   /**
@@ -233,7 +233,7 @@ public A call() throws Exception {
    * @return a function that turns an Either into a Callable.
    */
   public static <A> F<P1<Either<Exception, A>>, Callable<A>> fromEither() {
-    return e -> fromEither(e);
+    return Callables::fromEither;
   }
 
   /**
@@ -261,7 +261,7 @@ public A call() throws Exception {
    *         or throws an exception in the case of no value.
    */
   public static <A> F<P1<Option<A>>, Callable<A>> fromOption() {
-    return o -> fromOption(o);
+    return Callables::fromOption;
   }
 
   /**
@@ -285,7 +285,7 @@ public static <A> Callable<A> normalise(final Callable<A> a) {
    * @return A function that normalises the given Callable by calling it and wrapping the result in a new Callable.
    */
   public static <A> F<Callable<A>, Callable<A>> normalise() {
-    return a -> normalise(a);
+    return Callables::normalise;
   }
 
 }
diff --git a/core/src/main/java/fj/control/parallel/ParModule.java b/core/src/main/java/fj/control/parallel/ParModule.java
index 7d01139a..7e0fdb59 100644
--- a/core/src/main/java/fj/control/parallel/ParModule.java
+++ b/core/src/main/java/fj/control/parallel/ParModule.java
@@ -56,7 +56,7 @@ public <A> Promise<A> promise(final P1<A> p) {
    * @return a function that evaluates a given product concurrently and returns a Promise of the result.
    */
   public <A> F<P1<A>, Promise<A>> promise() {
-    return ap1 -> promise(ap1);
+    return this::promise;
   }
 
   /**
@@ -77,7 +77,7 @@ public <A, B> F<A, Promise<B>> promise(final F<A, B> f) {
    * @return A higher-order function that takes pure functions to promise-valued functions.
    */
   public <A, B> F<F<A, B>, F<A, Promise<B>>> promisePure() {
-    return abf -> promise(abf);
+    return this::promise;
   }
 
   /**
@@ -110,7 +110,7 @@ public <A> Actor<A> effect(final Effect1<A> e) {
    * @return A function that takes an effect and returns a concurrent effect.
    */
   public <A> F<Effect1<A>, Actor<A>> effect() {
-    return effect -> effect(effect);
+    return this::effect;
   }
 
   /**
@@ -129,7 +129,7 @@ public <A> Actor<A> actor(final Effect1<A> e) {
    * @return A function that takes an effect and returns an actor that processes messages in some order.
    */
   public <A> F<Effect1<A>, Actor<A>> actor() {
-    return effect -> actor(effect);
+    return this::actor;
   }
 
   /**
@@ -148,7 +148,7 @@ public <A> Promise<List<A>> sequence(final List<Promise<A>> ps) {
    * @return A first-class function that traverses a list inside a promise.
    */
   public <A> F<List<Promise<A>>, Promise<List<A>>> sequenceList() {
-    return list -> sequence(list);
+    return this::sequence;
   }
 
   /**
@@ -167,7 +167,7 @@ public <A> Promise<Stream<A>> sequence(final Stream<Promise<A>> ps) {
    * @return A first-class function that traverses a stream inside a promise.
    */
   public <A> F<Stream<Promise<A>>, Promise<Stream<A>>> sequenceStream() {
-    return stream -> sequence(stream);
+    return this::sequence;
   }
 
   /**
@@ -313,7 +313,7 @@ public <A, B> F<F<A, B>, F<Iterable<A>, Promise<Iterable<B>>>> parMapIterable()
    * @return A Promise of a new Array with the given function applied to each element.
    */
   public <A, B> Promise<Array<B>> parMap(final Array<A> as, final F<A, B> f) {
-    return parMap(as.toStream(), f).fmap(stream -> stream.toArray());
+    return parMap(as.toStream(), f).fmap(Stream::toArray);
   }
 
   /**
@@ -452,7 +452,7 @@ public <A, B, C> Promise<Stream<C>> parZipWith(final Stream<A> as, final Stream<
    * @return A Promise of a new array with the results of applying the given function across the two arrays, stepwise.
    */
   public <A, B, C> Promise<Array<C>> parZipWith(final Array<A> as, final Array<B> bs, final F<A, F<B, C>> f) {
-    return parZipWith(as.toStream(), bs.toStream(), f).fmap(stream -> stream.toArray());
+    return parZipWith(as.toStream(), bs.toStream(), f).fmap(Stream::toArray);
   }
 
   /**
@@ -515,7 +515,7 @@ public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final
   public <A, B> Promise<B> parFoldMap(final Iterable<A> as, final F<A, B> map, final Monoid<B> reduce,
                                       final F<Iterable<A>, P2<Iterable<A>, Iterable<A>>> chunking) {
     return parFoldMap(iterableStream(as), map, reduce, (Stream<A> stream) -> {
-      final F<Iterable<A>, Stream<A>> is = iterable -> iterableStream(iterable);
+      final F<Iterable<A>, Stream<A>> is = Stream::iterableStream;
       return chunking.f(stream).map1(is).map2(is);
     });
   }
diff --git a/core/src/main/java/fj/control/parallel/Promise.java b/core/src/main/java/fj/control/parallel/Promise.java
index 42f9e3c2..fc20f491 100644
--- a/core/src/main/java/fj/control/parallel/Promise.java
+++ b/core/src/main/java/fj/control/parallel/Promise.java
@@ -190,7 +190,7 @@ public void f(final B b) {
    * @return A new promise after applying the given promised function to this promise.
    */
   public <B> Promise<B> apply(final Promise<F<A, B>> pf) {
-    return pf.bind(f -> fmap(f));
+    return pf.bind(this::fmap);
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Strategy.java b/core/src/main/java/fj/control/parallel/Strategy.java
index 28bd6d32..79e698b9 100644
--- a/core/src/main/java/fj/control/parallel/Strategy.java
+++ b/core/src/main/java/fj/control/parallel/Strategy.java
@@ -168,7 +168,7 @@ public <B> F<List<B>, P1<List<A>>> parMapList(final F<B, A> f) {
    * @return A function that promotes another function to a parallel function on lists.
    */
   public <B> F<F<B, A>, F<List<B>, P1<List<A>>>> parMapList() {
-    return f1 -> parMapList(f1);
+    return this::parMapList;
   }
 
   /**
@@ -196,7 +196,7 @@ public <B> F<Array<B>, P1<Array<A>>> parMapArray(final F<B, A> f) {
    * @return A function that promotes another function to a parallel function on arrays.
    */
   public <B> F<F<B, A>, F<Array<B>, P1<Array<A>>>> parMapArray() {
-    return f1 -> parMapArray(f1);
+    return this::parMapArray;
   }
 
   /**
@@ -311,7 +311,7 @@ public <B, C> F2<Array<B>, Array<C>, P1<Array<A>>> parZipArrayWith(final F2<B, C
    * @return A function which, given a Future, yields a product-1 that waits for it.
    */
   public static <A> F<Future<A>, P1<A>> obtain() {
-    return t -> obtain(t);
+    return Strategy::obtain;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index d9231cb8..7890a0c8 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -527,7 +527,7 @@ public <B, C> Array<C> bind(final Array<B> sb, final F2<A, B, C> f) {
    * @return A new array after applying the given array of functions through this array.
    */
   public <B> Array<B> apply(final Array<F<A, B>> lf) {
-    return lf.bind(f -> map(a -> f.f(a)));
+    return lf.bind(f -> map(f::f));
   }
 
   /**
@@ -606,7 +606,7 @@ public static <A> Array<A> single(final A a) {
    * @return A function that wraps a given array.
    */
   public static <A> F<A[], Array<A>> wrap() {
-    return as -> array(as);
+    return Array::array;
   }
 
   /**
@@ -635,7 +635,7 @@ public static <A> Array<A> join(final Array<Array<A>> o) {
    * @return A function that joins a array of arrays using a bind operation.
    */
   public static <A> F<Array<Array<A>>, Array<A>> join() {
-    return as -> join(as);
+    return Array::join;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Conversions.java b/core/src/main/java/fj/data/Conversions.java
index 055da1dd..35cf68be 100644
--- a/core/src/main/java/fj/data/Conversions.java
+++ b/core/src/main/java/fj/data/Conversions.java
@@ -36,7 +36,7 @@ private Conversions() {
    * @return A function that converts lists to arrays.
    */
   public static <A> F<List<A>, Array<A>> List_Array() {
-    return as -> as.toArray();
+    return List::toArray;
   }
 
   /**
@@ -45,7 +45,7 @@ public static <A> F<List<A>, Array<A>> List_Array() {
    * @return A function that converts lists to streams.
    */
   public static <A> F<List<A>, Stream<A>> List_Stream() {
-    return as -> as.toStream();
+    return List::toStream;
   }
 
   /**
@@ -54,7 +54,7 @@ public static <A> F<List<A>, Stream<A>> List_Stream() {
    * @return A function that converts lists to options.
    */
   public static <A> F<List<A>, Option<A>> List_Option() {
-    return as -> as.headOption();
+    return List::headOption;
   }
 
   /**
@@ -69,7 +69,7 @@ public static <A, B> F<P1<A>, F<List<B>, Either<A, B>>> List_Either() {
   /**
    * A function that converts lists to strings.
    */
-  public static final F<List<Character>, String> List_String = cs -> asString(cs);
+  public static final F<List<Character>, String> List_String = List::asString;
 
   /**
    * A function that converts lists to string buffers.
@@ -91,7 +91,7 @@ public static <A, B> F<P1<A>, F<List<B>, Either<A, B>>> List_Either() {
    * @return A function that converts arrays to lists.
    */
   public static <A> F<Array<A>, List<A>> Array_List() {
-    return as -> as.toList();
+    return Array::toList;
   }
 
   /**
@@ -100,7 +100,7 @@ public static <A> F<Array<A>, List<A>> Array_List() {
    * @return A function that converts arrays to streams.
    */
   public static <A> F<Array<A>, Stream<A>> Array_Stream() {
-    return as -> as.toStream();
+    return Array::toStream;
   }
 
   /**
@@ -109,7 +109,7 @@ public static <A> F<Array<A>, Stream<A>> Array_Stream() {
    * @return A function that converts arrays to options.
    */
   public static <A> F<Array<A>, Option<A>> Array_Option() {
-    return as -> as.toOption();
+    return Array::toOption;
   }
 
   /**
@@ -126,7 +126,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    */
   public static final F<Array<Character>, String> Array_String = cs -> {
       final StringBuilder sb = new StringBuilder();
-      cs.foreachDoEffect(c -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb.toString();
   };
 
@@ -135,7 +135,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    */
   public static final F<Array<Character>, StringBuffer> Array_StringBuffer = cs -> {
       final StringBuffer sb = new StringBuffer();
-      cs.foreachDoEffect(c -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb;
   };
 
@@ -144,7 +144,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    */
   public static final F<Array<Character>, StringBuilder> Array_StringBuilder = cs -> {
       final StringBuilder sb = new StringBuilder();
-      cs.foreachDoEffect((Character c) -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb;
   };
 
@@ -158,7 +158,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    * @return A function that converts streams to lists.
    */
   public static <A> F<Stream<A>, List<A>> Stream_List() {
-    return as -> as.toList();
+    return Stream::toList;
   }
 
   /**
@@ -167,7 +167,7 @@ public static <A> F<Stream<A>, List<A>> Stream_List() {
    * @return A function that converts streams to arrays.
    */
   public static <A> F<Stream<A>, Array<A>> Stream_Array() {
-    return as -> as.toArray();
+    return Stream::toArray;
   }
 
   /**
@@ -176,7 +176,7 @@ public static <A> F<Stream<A>, Array<A>> Stream_Array() {
    * @return A function that converts streams to options.
    */
   public static <A> F<Stream<A>, Option<A>> Stream_Option() {
-    return as -> as.toOption();
+    return Stream::toOption;
   }
 
   /**
@@ -193,7 +193,7 @@ public static <A, B> F<P1<A>, F<Stream<B>, Either<A, B>>> Stream_Either() {
    */
   public static final F<Stream<Character>, String> Stream_String = cs -> {
       final StringBuilder sb = new StringBuilder();
-      cs.foreachDoEffect((Character c) -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb.toString();
     };
 
@@ -202,7 +202,7 @@ public static <A, B> F<P1<A>, F<Stream<B>, Either<A, B>>> Stream_Either() {
    */
   public static final F<Stream<Character>, StringBuffer> Stream_StringBuffer = cs -> {
       final StringBuffer sb = new StringBuffer();
-      cs.foreachDoEffect((Character c) -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb;
   };
 
@@ -211,7 +211,7 @@ public static <A, B> F<P1<A>, F<Stream<B>, Either<A, B>>> Stream_Either() {
    */
   public static final F<Stream<Character>, StringBuilder> Stream_StringBuilder = cs -> {
       final StringBuilder sb = new StringBuilder();
-      cs.foreachDoEffect((Character c) -> sb.append(c));
+      cs.foreachDoEffect(sb::append);
       return sb;
   };
 
@@ -225,7 +225,7 @@ public static <A, B> F<P1<A>, F<Stream<B>, Either<A, B>>> Stream_Either() {
    * @return A function that converts options to lists.
    */
   public static <A> F<Option<A>, List<A>> Option_List() {
-    return o -> o.toList();
+    return Option::toList;
   }
 
   /**
@@ -234,7 +234,7 @@ public static <A> F<Option<A>, List<A>> Option_List() {
    * @return A function that converts options to arrays.
    */
   public static <A> F<Option<A>, Array<A>> Option_Array() {
-    return o -> o.toArray();
+    return Option::toArray;
   }
 
   /**
@@ -243,7 +243,7 @@ public static <A> F<Option<A>, Array<A>> Option_Array() {
    * @return A function that converts options to streams.
    */
   public static <A> F<Option<A>, Stream<A>> Option_Stream() {
-    return o -> o.toStream();
+    return Option::toStream;
   }
 
   /**
@@ -275,7 +275,7 @@ public static <A, B> F<P1<A>, F<Option<B>, Either<A, B>>> Option_Either() {
     // BEGIN Effect
 
     public static F<Effect0, P1<Unit>> Effect0_P1() {
-        return e -> Effect0_P1(e);
+        return Conversions::Effect0_P1;
     }
 
     public static P1<Unit> Effect0_P1(Effect0 e) {
@@ -287,7 +287,7 @@ public static <A> F<A, Unit> Effect1_F(Effect1<A> e) {
     }
 
     public static <A> F<Effect1<A>, F<A, Unit>> Effect1_F() {
-        return e -> Effect1_F(e);
+        return Conversions::Effect1_F;
     }
 
     public static IO<Unit> Effect_IO(Effect0 e) {
@@ -298,7 +298,7 @@ public static IO<Unit> Effect_IO(Effect0 e) {
     }
 
     public static F<Effect0, IO<Unit>> Effect_IO() {
-        return e -> Effect_IO(e);
+        return Conversions::Effect_IO;
     }
 
     public static SafeIO<Unit> Effect_SafeIO(Effect0 e) {
@@ -309,7 +309,7 @@ public static SafeIO<Unit> Effect_SafeIO(Effect0 e) {
     }
 
     public static F<Effect0, SafeIO<Unit>> Effect_SafeIO() {
-        return e -> Effect_SafeIO(e);
+        return Conversions::Effect_SafeIO;
     }
 
     // END Effect
@@ -451,7 +451,7 @@ public static <A> SafeIO<A> F_SafeIO(F<Unit, A> f) {
     }
 
     public static <A> F<F<Unit, A>, SafeIO<A>> F_SafeIO() {
-        return f -> F_SafeIO(f);
+        return Conversions::F_SafeIO;
     }
 
     // END F
@@ -461,7 +461,7 @@ public static <A> F<F<Unit, A>, SafeIO<A>> F_SafeIO() {
   /**
    * A function that converts strings to lists.
    */
-  public static final F<String, List<Character>> String_List = s -> fromString(s);
+  public static final F<String, List<Character>> String_List = List::fromString;
 
   /**
    * A function that converts strings to arrays.
@@ -490,12 +490,12 @@ public static <A> F<P1<A>, F<String, Either<A, Character>>> String_Either() {
   /**
    * A function that converts strings to string buffers.
    */
-  public static final F<String, StringBuffer> String_StringBuffer = s -> new StringBuffer(s);
+  public static final F<String, StringBuffer> String_StringBuffer = StringBuffer::new;
 
   /**
    * A function that converts strings to string builders.
    */
-  public static final F<String, StringBuilder> String_StringBuilder = s -> new StringBuilder(s);
+  public static final F<String, StringBuilder> String_StringBuilder = StringBuilder::new;
 
   // END String ->
 
@@ -533,12 +533,12 @@ public static <A> F<P1<A>, F<StringBuffer, Either<A, Character>>> StringBuffer_E
   /**
    * A function that converts string buffers to strings.
    */
-  public static final F<StringBuffer, String> StringBuffer_String = s -> s.toString();
+  public static final F<StringBuffer, String> StringBuffer_String = StringBuffer::toString;
 
   /**
    * A function that converts string buffers to string builders.
    */
-  public static final F<StringBuffer, StringBuilder> StringBuffer_StringBuilder = s -> new StringBuilder(s);
+  public static final F<StringBuffer, StringBuilder> StringBuffer_StringBuilder = StringBuilder::new;
 
   // END StringBuffer ->
 
@@ -576,12 +576,12 @@ public static <A> F<P1<A>, F<StringBuilder, Either<A, Character>>> StringBuilder
   /**
    * A function that converts string builders to strings.
    */
-  public static final F<StringBuilder, String> StringBuilder_String = s -> s.toString();
+  public static final F<StringBuilder, String> StringBuilder_String = StringBuilder::toString;
 
   /**
    * A function that converts string builders to string buffers.
    */
-  public static final F<StringBuilder, StringBuffer> StringBuilder_StringBuffer = s -> new StringBuffer(s);
+  public static final F<StringBuilder, StringBuffer> StringBuilder_StringBuffer = StringBuffer::new;
 
   // END StringBuilder ->
 
@@ -593,15 +593,15 @@ public static <A, B, Z extends Exception> SafeIO<Validation<Z, A>> Try_SafeIO(Tr
     }
 
     public static <A, B, Z extends Exception> F<Try0<A, Z>, SafeIO<Validation<Z, A>>> Try_SafeIO() {
-        return t -> Try_SafeIO(t);
+        return Conversions::Try_SafeIO;
     }
 
     public static <A, B, Z extends IOException> IO<A> Try_IO(Try0<A, Z> t) {
-        return () -> t.f();
+        return t::f;
     }
 
     public static <A, B, Z extends IOException> F<Try0<A, Z>, IO<A>> Try_IO() {
-        return t -> Try_IO(t);
+        return Conversions::Try_IO;
     }
 
     public static <A, B, Z extends IOException> F<A, Validation<Z, B>> Try_F(Try1<A, B, Z> t) {
@@ -609,7 +609,7 @@ public static <A, B, Z extends IOException> F<A, Validation<Z, B>> Try_F(Try1<A,
     }
 
     public static <A, B, Z extends IOException> F<Try1<A, B, Z>, F<A, Validation<Z, B>>> Try_F() {
-        return t -> Try_F(t);
+        return Conversions::Try_F;
     }
 
     // END Try
diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 6381ee78..1cbecb5d 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -296,7 +296,7 @@ public <X> Either<X, B> sequence(final Either<X, B> e) {
        */
       public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
           return isLeft() ?
-                  f.f(value()).map(x -> Either.<C, B>left(x)) :
+                  f.f(value()).map(Either::<C, B>left) :
                   list(Either.<C, B>right(e.right().value()));
       }
 
@@ -308,7 +308,7 @@ public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
        */
       public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
           return isRight() ?
-                  IOFunctions.map(f.f(value()), x -> Either.<C, B>left(x)) :
+                  IOFunctions.map(f.f(value()), Either::<C, B>left) :
                   IOFunctions.unit(Either.<C, B>right(e.right().value()));
       }
 
@@ -335,7 +335,7 @@ public <X> Option<Either<A, X>> filter(final F<A, Boolean> f) {
      * @return The result of function application within either.
      */
     public <X> Either<X, B> apply(final Either<F<A, X>, B> e) {
-      return e.left().bind(f -> map(f));
+      return e.left().bind(this::map);
     }
 
     /**
@@ -416,13 +416,13 @@ public Collection<A> toCollection() {
 
    public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
        return isLeft() ?
-               f.f(value()).map(x -> Either.<C, B>left(x)) :
+               f.f(value()).map(Either::<C, B>left) :
                some(Either.<C, B>right(e.right().value()));
    }
 
   public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
       return isLeft() ?
-              f.f(value()).map(c -> Either.<C, B>left(c)) :
+              f.f(value()).map(Either::<C, B>left) :
               Stream.single(Either.<C, B>right(e.right().value()));
   }
   }
@@ -561,7 +561,7 @@ public <X> Either<A, X> sequence(final Either<A, X> e) {
     */
       public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> right(x)) :
+                  f.f(value()).map(Either::right) :
                   list(Either.<A, C>left(e.left().value()));
       }
 
@@ -573,19 +573,19 @@ public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
        */
       public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
           return isRight() ?
-                  IOFunctions.map(f.f(value()), x -> Either.<A, C>right(x)) :
+                  IOFunctions.map(f.f(value()), Either::<A, C>right) :
                   IOFunctions.lazy(() -> Either.<A, C>left(e.left().value()));
       }
 
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> Either.<A, C>right(x)) :
+                  f.f(value()).map(Either::<A, C>right) :
                   p(Either.<A, C>left(e.left().value()));
       }
 
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> Either.<A, C>right(x)) :
+                  f.f(value()).map(Either::<A, C>right) :
                   some(Either.<A, C>left(e.left().value()));
       }
 
@@ -612,7 +612,7 @@ public <X> Option<Either<X, B>> filter(final F<B, Boolean> f) {
      * @return The result of function application within either.
      */
     public <X> Either<A, X> apply(final Either<A, F<B, X>> e) {
-      return e.right().bind(f -> map(f));
+      return e.right().bind(this::map);
     }
 
     /**
@@ -693,7 +693,7 @@ public Collection<B> toCollection() {
 
       public <C> Stream<Either<A, C>> traverseStream(F<B, Stream<C>> f) {
           return isRight() ?
-                  f.f(value()).map(x -> right(x)) :
+                  f.f(value()).map(Either::right) :
                   Stream.<Either<A,C>>single(left(e.left().value()));
 
       }
@@ -715,7 +715,7 @@ public static <A, B> Either<A, B> left(final A a) {
    * @return A function that constructs a left value of either.
    */
   public static <A, B> F<A, Either<A, B>> left_() {
-    return a -> left(a);
+    return Either::left;
   }
 
   /**
@@ -724,7 +724,7 @@ public static <A, B> F<A, Either<A, B>> left_() {
    * @return A function that constructs a right value of either.
    */
   public static <A, B> F<B, Either<A, B>> right_() {
-    return b -> right(b);
+    return Either::right;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index 14edff71..b7533ffd 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -369,7 +369,7 @@ else if (l < 0L) {
    */
   public static final Enumerator<Natural> naturalEnumerator = enumerator(
       n -> some(n.succ()),
-      n -> n.pred(),
+      Natural::pred,
       Option.<Natural>none(), some(Natural.ZERO), naturalOrd,
       curry((n, l) ->
         some(n).apply(
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index e45d94a5..6b03a96a 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -161,7 +161,7 @@ public Option<V> get(final K k) {
    * @return A curried version of {@link #get(Object)}.
    */
   public F<K, Option<V>> get() {
-    return k -> get(k);
+    return this::get;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 6aa5db12..b62bb60e 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -18,6 +18,7 @@
 import fj.data.Iteratee.Input;
 import fj.data.Iteratee.IterV;
 import fj.function.Try0;
+import fj.function.Try1;
 
 /**
  * IO monad for processing files, with main methods {@link #enumFileLines },
@@ -35,7 +36,7 @@ private IOFunctions() {
     }
 
     public static <A> Try0<A, IOException> toTry(IO<A> io) {
-        return () -> io.run();
+        return io::run;
     }
 
     public static <A> P1<Validation<IOException, A>> p(IO<A> io) {
@@ -47,10 +48,10 @@ public static <A> IO<A> fromF(F0<A> p) {
     }
 
     public static <A> IO<A> fromTry(Try0<A, ? extends IOException> t) {
-        return () -> t.f();
+        return t::f;
     }
 
-    public static final F<Reader, IO<Unit>> closeReader = r -> closeReader(r);
+    public static final F<Reader, IO<Unit>> closeReader = IOFunctions::closeReader;
 
     /**
      * Convert io to a SafeIO, throwing any IOException wrapped inside a RuntimeException
@@ -127,7 +128,7 @@ public static <A> IO<IterV<Character, A>> enumFileChars(final File f, final Opti
     }
 
     public static IO<BufferedReader> bufferedReader(final File f, final Option<Charset> encoding) {
-        return map(fileReader(f, encoding), a -> new BufferedReader(a));
+        return map(fileReader(f, encoding), BufferedReader::new);
     }
 
     public static IO<Reader> fileReader(final File f, final Option<Charset> encoding) {
@@ -386,7 +387,7 @@ public static <A> IO<A> join(IO<IO<A>> io1) {
     }
 
     public static <A> SafeIO<Validation<IOException, A>> toSafeValidation(IO<A> io) {
-        return () -> Try.f(() -> io.run())._1();
+        return () -> Try.f(io::run)._1();
     }
 
     public static <A, B> IO<B> append(final IO<A> io1, final IO<B> io2) {
@@ -458,8 +459,8 @@ public Stream<A> run() throws IOException {
                         return Stream.nil();
                     } else {
                         IO<Stream<A>> io2 = sequenceWhile(stream.tail()._1(), f);
-                        SafeIO<Stream<A>> s3 = toSafe(() -> io2.run());
-                        return Stream.cons(a, () -> s3.run());
+                        SafeIO<Stream<A>> s3 = toSafe(io2::run);
+                        return Stream.cons(a, s3::run);
                     }
                 }
             }
@@ -467,7 +468,7 @@ public Stream<A> run() throws IOException {
     }
 
     public static <A, B> IO<B> apply(IO<A> io, IO<F<A, B>> iof) {
-        return bind(iof, f -> map(io, a -> f.f(a)));
+        return bind(iof, f -> map(io, f::f));
     }
 
     public static <A, B, C> IO<C> liftM2(IO<A> ioa, IO<B> iob, F2<A, B, C> f) {
@@ -479,13 +480,13 @@ public static <A> IO<List<A>> replicateM(IO<A> ioa, int n) {
     }
 
     public static <A> IO<State<BufferedReader, Validation<IOException, String>>> readerState() {
-        return () -> State.unit((BufferedReader r) -> P.p(r, Try.f((BufferedReader r2) -> r2.readLine()).f(r)));
+        return () -> State.unit((BufferedReader r) -> P.p(r, Try.f((Try1<BufferedReader, String, IOException>) BufferedReader::readLine).f(r)));
     }
 
     public static final BufferedReader stdinBufferedReader = new BufferedReader(new InputStreamReader(System.in));
 
     public static IO<String> stdinReadLine() {
-        return () -> stdinBufferedReader.readLine();
+        return stdinBufferedReader::readLine;
     }
 
     public static IO<Unit> stdoutPrintln(final String s) {
diff --git a/core/src/main/java/fj/data/IterableW.java b/core/src/main/java/fj/data/IterableW.java
index 9e36e710..0633ffd4 100644
--- a/core/src/main/java/fj/data/IterableW.java
+++ b/core/src/main/java/fj/data/IterableW.java
@@ -42,7 +42,7 @@ public static <A> IterableW<A> wrap(final Iterable<A> a) {
    * @return A function that returns the given iterable, wrapped.
    */
   public static <A, T extends Iterable<A>> F<T, IterableW<A>> wrap() {
-    return a -> wrap(a);
+    return IterableW::wrap;
   }
 
   /**
@@ -73,7 +73,7 @@ public static <A, B> F<A, IterableW<B>> iterable(final F<A, B> f) {
    * @return A transformation from a function to the equivalent Iterable-valued function.
    */
   public static <A, B> F<F<A, B>, F<A, IterableW<B>>> arrow() {
-    return f -> iterable(f);
+    return IterableW::iterable;
   }
 
   /**
@@ -93,7 +93,7 @@ public <B, T extends Iterable<B>> IterableW<B> bind(final F<A, T> f) {
    * @return A new iterable after applying the given iterable function to the wrapped iterable.
    */
   public <B> IterableW<B> apply(final Iterable<F<A, B>> f) {
-    return wrap(f).bind(f1 -> map(f1));
+    return wrap(f).bind(this::map);
   }
 
   /**
@@ -143,7 +143,7 @@ public static <A, T extends Iterable<A>> IterableW<IterableW<A>> sequence(final
    * @return a function that binds a given function across a given iterable.
    */
   public static <A, B, T extends Iterable<B>> F<IterableW<A>, F<F<A, T>, IterableW<B>>> bind() {
-    return a -> f -> a.bind(f);
+    return a -> a::bind;
   }
 
   /**
@@ -163,7 +163,7 @@ public static <A, T extends Iterable<A>> IterableW<A> join(final Iterable<T> as)
    * @return a function that joins an Iterable of Iterables into a single Iterable.
    */
   public static <A, T extends Iterable<A>> F<Iterable<T>, IterableW<A>> join() {
-    return a -> join(a);
+    return IterableW::join;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index e2f9adfd..8836fe2f 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -1433,7 +1433,7 @@ public static F<StringBuilder, SynchronousQueue<Character>> StringBuilder_Synchr
    * @return A function that converts array lists to lists.
    */
   public static <A> F<ArrayList<A>, List<A>> ArrayList_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1447,11 +1447,11 @@ public static <A> F<ArrayList<A>, List<A>> ArrayList_List() {
    * @return A function that converts Java lists to lists.
    */
   public static <A> F<java.util.List<A>, List<A>> JUList_List() {
-    return as -> JavaList_List(as);
+    return Java::JavaList_List;
   }
 
   public static <A> F<java.util.List<A>, List<A>> JavaList_List() {
-    return as -> JavaList_List(as);
+    return Java::JavaList_List;
   }
 
   public static <A> List<A> JavaList_List(java.util.List<A> list) {
@@ -1479,7 +1479,7 @@ public static <A> List<A> JavaList_List(java.util.List<A> list) {
    * @return A function that converts enum sets to lists.
    */
   public static <A extends Enum<A>> F<EnumSet<A>, List<A>> EnumSet_List() {
-	  return as -> Collection_List(as);
+	  return Java::Collection_List;
   }
 
 	public static <A> List<A> Collection_List(Collection<A> c) {
@@ -1507,7 +1507,7 @@ private static <E> E[] array(int length, E... array) {
    * @return A function that converts hash sets to lists.
    */
   public static <A> F<HashSet<A>, List<A>> HashSet_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1522,7 +1522,7 @@ public static <A> F<HashSet<A>, List<A>> HashSet_List() {
    * @return A function that converts linked hash sets to lists.
    */
   public static <A> F<LinkedHashSet<A>, List<A>> LinkedHashSet_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1537,7 +1537,7 @@ public static <A> F<LinkedHashSet<A>, List<A>> LinkedHashSet_List() {
    * @return A function that converts linked lists to lists.
    */
   public static <A> F<LinkedList<A>, List<A>> LinkedList_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1552,7 +1552,7 @@ public static <A> F<LinkedList<A>, List<A>> LinkedList_List() {
    * @return A function that converts priority queues to lists.
    */
   public static <A> F<PriorityQueue<A>, List<A>> PriorityQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1567,7 +1567,7 @@ public static <A> F<PriorityQueue<A>, List<A>> PriorityQueue_List() {
    * @return A function that converts stacks to lists.
    */
   public static <A> F<Stack<A>, List<A>> Stack_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1582,7 +1582,7 @@ public static <A> F<Stack<A>, List<A>> Stack_List() {
    * @return A function that converts tree sets to lists.
    */
   public static <A> F<TreeSet<A>, List<A>> TreeSet_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1597,7 +1597,7 @@ public static <A> F<TreeSet<A>, List<A>> TreeSet_List() {
    * @return A function that converts vectors to lists.
    */
   public static <A> F<Vector<A>, List<A>> Vector_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1612,7 +1612,7 @@ public static <A> F<Vector<A>, List<A>> Vector_List() {
    * @return A function that converts array blocking queues to lists.
    */
   public static <A> F<ArrayBlockingQueue<A>, List<A>> ArrayBlockingQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1627,7 +1627,7 @@ public static <A> F<ArrayBlockingQueue<A>, List<A>> ArrayBlockingQueue_List() {
    * @return A function that converts concurrent linked queues to lists.
    */
   public static <A> F<ConcurrentLinkedQueue<A>, List<A>> ConcurrentLinkedQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1642,7 +1642,7 @@ public static <A> F<ConcurrentLinkedQueue<A>, List<A>> ConcurrentLinkedQueue_Lis
    * @return A function that converts copy on write array lists to lists.
    */
   public static <A> F<CopyOnWriteArrayList<A>, List<A>> CopyOnWriteArrayList_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1657,7 +1657,7 @@ public static <A> F<CopyOnWriteArrayList<A>, List<A>> CopyOnWriteArrayList_List(
    * @return A function that converts copy on write array sets to lists.
    */
   public static <A> F<CopyOnWriteArraySet<A>, List<A>> CopyOnWriteArraySet_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1672,7 +1672,7 @@ public static <A> F<CopyOnWriteArraySet<A>, List<A>> CopyOnWriteArraySet_List()
    * @return A function that converts delay queues to lists.
    */
   public static <A extends Delayed> F<DelayQueue<A>, List<A>> DelayQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1687,7 +1687,7 @@ public static <A extends Delayed> F<DelayQueue<A>, List<A>> DelayQueue_List() {
    * @return A function that converts linked blocking queues to lists.
    */
   public static <A> F<LinkedBlockingQueue<A>, List<A>> LinkedBlockingQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1702,7 +1702,7 @@ public static <A> F<LinkedBlockingQueue<A>, List<A>> LinkedBlockingQueue_List()
    * @return A function that converts priority blocking queues to lists.
    */
   public static <A> F<PriorityBlockingQueue<A>, List<A>> PriorityBlockingQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1717,7 +1717,7 @@ public static <A> F<PriorityBlockingQueue<A>, List<A>> PriorityBlockingQueue_Lis
    * @return A function that converts synchronous queues to lists.
    */
   public static <A> F<SynchronousQueue<A>, List<A>> SynchronousQueue_List() {
-    return as -> Collection_List(as);
+    return Java::Collection_List;
   }
 
   // todo
@@ -1727,7 +1727,7 @@ public static <A> F<SynchronousQueue<A>, List<A>> SynchronousQueue_List() {
   // BEGIN Callable ->
 
   public static <A> F<P1<A>, Callable<A>> P1_Callable() {
-    return a -> () -> a._1();
+    return a -> a::_1;
   }
 
 // END Callable ->
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 0b5a0d4c..5a2e2504 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -655,7 +655,7 @@ public <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
   public <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
     return this.foldRight(
         (a, acc) -> Function.bind(acc,
-            (bs) -> Function.<C, B, List<B>> compose(b -> bs.cons(b), f.f(a))),
+            (bs) -> Function.<C, B, List<B>> compose(bs::cons, f.f(a))),
         constant(List.<B> nil())
         );
   }
@@ -697,7 +697,7 @@ public <B> V2<List<B>> traverseV2(final F<A, V2<B>> f) {
    * @return A new list after applying the given list of functions through this list.
    */
   public final <B> List<B> apply(final List<F<A, B>> lf) {
-    return lf.bind(f -> map(f));
+    return lf.bind(this::map);
   }
 
   /**
@@ -1041,7 +1041,7 @@ public final <B> List<P2<A, B>> zip(final List<B> bs) {
    * @return A function that zips the given lists to produce a list of pairs.
    */
   public static <A, B> F<List<A>, F<List<B>, List<P2<A, B>>>> zip() {
-    return curry((as, bs) -> as.zip(bs));
+    return curry(List::zip);
   }
 
   /**
@@ -1164,7 +1164,7 @@ public final List<A> nub(final Ord<A> o) {
    * @return A function that gets the head of a given list.
    */
   public static <A> F<List<A>, A> head_() {
-    return list -> list.head();
+    return List::head;
   }
 
 
@@ -1182,7 +1182,7 @@ public Option<List<A>> tailOption() {
    * @return A function that gets the tail of a given list.
    */
   public static <A> F<List<A>, List<A>> tail_() {
-    return list -> list.tail();
+    return List::tail;
   }
 
   /**
@@ -1446,7 +1446,7 @@ public final boolean isSuffixOf(final Equal<A> eq, final List<A> xs) {
    * @return A function that gets the length of a given list.
    */
   public static <A> F<List<A>, Integer> length_() {
-    return a -> a.length();
+    return List::length;
   }
 
   /**
@@ -1607,7 +1607,7 @@ public static <A> F<A, F<List<A>, List<A>>> cons() {
   }
 
   public static <A> F2<A, List<A>, List<A>> cons_() {
-      return (a, listA) -> cons(a, listA);
+      return List::cons;
   }
 
   /**
@@ -1617,7 +1617,7 @@ public static <A> F2<A, List<A>, List<A>> cons_() {
    * @return A function that prepends a value to the given list.
    */
   public static <A> F<A, List<A>> cons(final List<A> tail) {
-    return a -> tail.cons(a);
+    return tail::cons;
   }
 
   /**
@@ -1647,7 +1647,7 @@ public static <A> List<A> cons(final A head, final List<A> tail) {
    * @return A function that determines whether a given list is empty.
    */
   public static <A> F<List<A>, Boolean> isEmpty_() {
-    return as -> as.isEmpty();
+    return List::isEmpty;
   }
 
   /**
@@ -1656,7 +1656,7 @@ public static <A> F<List<A>, Boolean> isEmpty_() {
    * @return A function that determines whether a given list is not empty.
    */
   public static <A> F<List<A>, Boolean> isNotEmpty_() {
-    return as -> as.isNotEmpty();
+    return List::isNotEmpty;
   }
 
   /**
@@ -1676,7 +1676,7 @@ public static <A> List<A> join(final List<List<A>> o) {
    * @return A function that joins a list of lists using a bind operation.
    */
   public static <A> F<List<List<A>>, List<A>> join() {
-    return as -> join(as);
+    return List::join;
   }
 
   /**
@@ -1762,7 +1762,7 @@ public static List<Character> fromString(final String s) {
    * @return A first-class <code>fromString</code>.
    */
   public static F<String, List<Character>> fromString() {
-    return s -> fromString(s);
+    return List::fromString;
   }
 
   /**
@@ -1788,7 +1788,7 @@ public static String asString(final List<Character> cs) {
    * @return A first-class <code>asString</code>.
    */
   public static F<List<Character>, String> asString() {
-    return cs -> asString(cs);
+    return List::asString;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Natural.java b/core/src/main/java/fj/data/Natural.java
index 396aa39c..1779d8c7 100644
--- a/core/src/main/java/fj/data/Natural.java
+++ b/core/src/main/java/fj/data/Natural.java
@@ -40,7 +40,7 @@ public static Option<Natural> natural(final BigInteger i) {
    * A function that returns the natural number equal to a given BigInteger
    */
   public static final F<BigInteger, Option<Natural>> fromBigInt =
-          i -> natural(i);
+      Natural::natural;
 
   /**
    * Returns the natural number equal to the given long
@@ -77,7 +77,7 @@ public Natural succ() {
    * @return A function that returns the successor of a given natural number.
    */
   public static F<Natural, Natural> succ_() {
-    return natural -> natural.succ();
+    return Natural::succ;
   }
 
   /**
@@ -95,7 +95,7 @@ public Option<Natural> pred() {
    * @return A function that returns the predecessor of a given natural number, or None if it's zero.
    */
   public static F<Natural, Option<Natural>> pred_() {
-    return natural -> natural.pred();
+    return Natural::pred;
   }
 
   /**
@@ -111,7 +111,7 @@ public Natural add(final Natural n) {
   /**
    * A function that adds two natural numbers.
    */
-  public static final F<Natural, F<Natural, Natural>> add = curry((n1, n2) -> n1.add(n2));
+  public static final F<Natural, F<Natural, Natural>> add = curry(Natural::add);
 
 
   /**
@@ -143,7 +143,7 @@ public Natural multiply(final Natural n) {
   /**
    * A function that multiplies a natural number by another.
    */
-  public static final F<Natural, F<Natural, Natural>> multiply = curry((n1, n2) -> n1.multiply(n2));
+  public static final F<Natural, F<Natural, Natural>> multiply = curry(Natural::multiply);
 
 
   /**
@@ -245,7 +245,7 @@ public int intValue() {
   /**
    * A function that returns the BigInteger value of a given Natural.
    */
-  public static final F<Natural, BigInteger> bigIntegerValue = n -> n.bigIntegerValue();
+  public static final F<Natural, BigInteger> bigIntegerValue = Natural::bigIntegerValue;
 
   /**
    * Sums a stream of natural numbers.
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index 0ebffc11..611bef93 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -127,7 +127,7 @@ public void f(final A a) {
   public NonEmptyList<NonEmptyList<A>> sublists() {
     return fromList(
         somes(toList().toStream().substreams()
-            .map(F1Functions.o(list -> fromList(list), Conversions.<A>Stream_List())).toList())).some();
+            .map(F1Functions.o(NonEmptyList::fromList, Conversions.<A>Stream_List())).toList())).some();
   }
 
   /**
@@ -137,7 +137,7 @@ public NonEmptyList<NonEmptyList<A>> sublists() {
    * @return A NonEmptyList of the tails of this list.
    */
   public NonEmptyList<NonEmptyList<A>> tails() {
-    return fromList(somes(toList().tails().map(list -> fromList(list)))).some();
+    return fromList(somes(toList().tails().map(NonEmptyList::fromList))).some();
   }
 
   /**
@@ -268,7 +268,7 @@ public Collection<A> toCollection() {
    * @return A function that takes a non-empty list to a list.
    */
   public static <A> F<NonEmptyList<A>, List<A>> toList_() {
-    return as -> as.toList();
+    return NonEmptyList::toList;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 5bec1ea4..5c8dca74 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -95,7 +95,7 @@ public final boolean isNone() {
    * @return A function that returns true if a given optional value has a value, otherwise false.
    */
   public static <A> F<Option<A>, Boolean> isSome_() {
-    return a -> a.isSome();
+    return Option::isSome;
   }
 
   /**
@@ -104,7 +104,7 @@ public static <A> F<Option<A>, Boolean> isSome_() {
    * @return A function that returns false if a given optional value has a value, otherwise true.
    */
   public static <A> F<Option<A>, Boolean> isNone_() {
-    return a -> a.isNone();
+    return Option::isNone;
   }
 
   /**
@@ -412,15 +412,15 @@ public final <B> Option<B> sequence(final Option<B> o) {
   }
 
   public <L, B> Either<L, Option<B>> traverseEither(F<A, Either<L, B>> f) {
-    return map(a -> f.f(a).right().map(b -> some(b))).orSome(Either.right(none()));
+    return map(a -> f.f(a).right().map(Option::some)).orSome(Either.right(none()));
   }
 
   public <B> IO<Option<B>> traverseIO(F<A, IO<B>> f) {
-    return map(a -> IOFunctions.map(f.f(a), b -> some(b))).orSome(IOFunctions.lazy(() -> none()));
+    return map(a -> IOFunctions.map(f.f(a), Option::some)).orSome(IOFunctions.lazy(Option::none));
   }
 
   public <B> List<Option<B>> traverseList(F<A, List<B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(List.list());
+    return map(a -> f.f(a).map(Option::some)).orSome(List.list());
   }
 
   public <B> Option<Option<B>> traverseOption(F<A, Option<B>> f) {
@@ -428,28 +428,28 @@ public <B> Option<Option<B>> traverseOption(F<A, Option<B>> f) {
   }
 
   public <B> Stream<Option<B>> traverseStream(F<A, Stream<B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(Stream.nil());
+    return map(a -> f.f(a).map(Option::some)).orSome(Stream.nil());
   }
 
   public <B> P1<Option<B>> traverseP1(F<A, P1<B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(p(none()));
+    return map(a -> f.f(a).map(Option::some)).orSome(p(none()));
   }
 
   public <B> Seq<Option<B>> traverseSeq(F<A, Seq<B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(Seq.empty());
+    return map(a -> f.f(a).map(Option::some)).orSome(Seq.empty());
   }
 
   public <B> Set<Option<B>> traverseSet(Ord<B> ord, F<A, Set<B>> f) {
     Ord<Option<B>> optOrd = Ord.optionOrd(ord);
-    return map(a -> f.f(a).map(optOrd, b -> some(b))).orSome(Set.empty(optOrd));
+    return map(a -> f.f(a).map(optOrd, Option::some)).orSome(Set.empty(optOrd));
   }
 
   public <B> F2<Ord<B>, F<A, Set<B>>, Set<Option<B>>> traverseSet() {
-    return (o, f) -> traverseSet(o, f);
+    return this::traverseSet;
   }
 
   public <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<E, B>> f) {
-    return map(a -> f.f(a).map(b -> some(b))).orSome(Validation.success(none()));
+    return map(a -> f.f(a).map(Option::some)).orSome(Validation.success(none()));
   }
 
   /**
@@ -460,7 +460,7 @@ public <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<E, B>>
    *         optional value.
    */
   public final <B> Option<B> apply(final Option<F<A, B>> of) {
-    return of.bind(f -> map(a -> f.f(a)));
+    return of.bind(f -> map(f::f));
   }
 
   /**
@@ -516,7 +516,7 @@ public final <X> Validation<X, A> toValidation(final X x) {
    *         return in left.
    */
   public static <A, X> F<Option<A>, F<X, Either<X, A>>> toEither() {
-    return curry((a, x) -> a.toEither(x));
+    return curry(Option::toEither);
   }
 
   /**
@@ -641,7 +641,7 @@ public A some() {
 
 
   public static <T> F<T, Option<T>> some_() {
-    return t -> some(t);
+    return Option::some;
   }
 
   /**
@@ -685,7 +685,7 @@ public static <T> Option<T> fromNull(final T t) {
    * @return If <code>t == null</code> then return none, otherwise, return it in some.
    */
   public static <T> F<T, Option<T>> fromNull() {
-    return t -> fromNull(t);
+    return Option::fromNull;
   }
 
   /**
@@ -758,7 +758,7 @@ public static <A> Option<A> iif(final boolean p, final A a) {
    *         holds on that argument, or no value otherwise.
    */
   public static <A> F2<F<A, Boolean>, A, Option<A>> iif() {
-    return (p, a) -> iif(p, a);
+    return Option::iif;
   }
 
   /**
@@ -808,7 +808,7 @@ public int hashCode() {
    *         or no value if the string is empty.
    */
   public static F<String, Option<String>> fromString() {
-    return s -> fromString(s);
+    return Option::fromString;
   }
 
   /**
@@ -855,7 +855,7 @@ public static <A, B> F<F<A, Option<B>>, F<Option<A>, Option<B>>> bind() {
    * @return A function that joins an Option of an Option to make a single Option.
    */
   public static <A> F<Option<Option<A>>, Option<A>> join() {
-    return option -> join(option);
+    return Option::join;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 09d80279..4dcd10de 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -173,7 +173,7 @@ public final boolean member(final A x) {
    * @return A function that returns true if the given element if a member of the given set.
    */
   public static <A> F<Set<A>, F<A, Boolean>> member() {
-    return curry((s, a) -> s.member(a));
+    return curry(Set::member);
   }
 
   /**
@@ -394,7 +394,7 @@ public final Set<A> union(final Set<A> s) {
    * @see #union(Set)
    */
   public static <A> F<Set<A>, F<Set<A>, Set<A>>> union() {
-    return curry((s1, s2) -> s1.union(s2));
+    return curry(Set::union);
   }
 
   /**
@@ -444,7 +444,7 @@ public final Set<A> intersect(final Set<A> s) {
    * @see #intersect(Set)
    */
   public static <A> F<Set<A>, F<Set<A>, Set<A>>> intersect() {
-    return curry((s1, s2) -> s1.intersect(s2));
+    return curry(Set::intersect);
   }
 
   /**
@@ -464,7 +464,7 @@ public final Set<A> minus(final Set<A> s) {
    * @see #minus(Set)
    */
   public static <A> F<Set<A>, F<Set<A>, Set<A>>> minus() {
-    return curry((s1, s2) -> s1.minus(s2));
+    return curry(Set::minus);
   }
 
     public Option<A> min() {
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 81146f95..47703e7b 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -93,7 +93,7 @@ public State<S, A> withs(F<S, S> f) {
 	}
 
 	public static <S, A> State<S, A> gets(F<S, A> f) {
-		return State.<S>init().map(s -> f.f(s));
+		return State.<S>init().map(f::f);
 	}
 
 	/**
@@ -101,7 +101,7 @@ public static <S, A> State<S, A> gets(F<S, A> f) {
 	 */
 	public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
 		return list.foldLeft((State<S, List<A>> acc, State<S, A> ma) ->
-			acc.flatMap((List<A> xs) -> ma.map((A x) -> xs.snoc(x))
+			acc.flatMap((List<A> xs) -> ma.map(xs::snoc)
 		), constant(List.<A>nil()));
 	}
 
@@ -111,7 +111,7 @@ public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
 	 */
 	public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B>> f) {
 		return list.foldLeft((State<S, List<B>> acc, A a) ->
-			acc.flatMap(bs -> f.f(a).map(b -> bs.snoc(b))
+			acc.flatMap(bs -> f.f(a).map(bs::snoc)
 		), constant(List.<B>nil()));
 	}
 
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 6dbcf778..8e04e499 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -2,6 +2,7 @@
 
 import fj.Equal;
 import fj.F0;
+import fj.F3;
 import fj.Hash;
 import fj.Show;
 import fj.F;
@@ -521,7 +522,7 @@ public final <B> Stream<B> sequence(final Stream<B> bs) {
    * @return The stream of IOs after sequencing.
    */
   public static <A> Stream<IO<A>> sequence(final IO<Stream<A>> io) {
-    return IOFunctions.runSafe(io).map(a -> IOFunctions.unit(a));
+    return IOFunctions.runSafe(io).map(IOFunctions::unit);
   }
 
   /**
@@ -531,7 +532,7 @@ public static <A> Stream<IO<A>> sequence(final IO<Stream<A>> io) {
    * @return The stream of (pre-calculated) lazy values after sequencing.
    */
   public static <A> Stream<P1<A>> sequence(final F0<Stream<A>> p) {
-    return p.f().map(a -> p(a));
+    return p.f().map(P::p);
   }
 
   /**
@@ -541,7 +542,7 @@ public static <A> Stream<P1<A>> sequence(final F0<Stream<A>> p) {
    * @return The stream of options after sequencing.
    */
   public static <A> Stream<Option<A>> sequence(final Option<Stream<A>> o) {
-    return o.isNone() ? nil() : o.some().map(a -> some(a));
+    return o.isNone() ? nil() : o.some().map(Option::some);
   }
 
   /**
@@ -551,7 +552,7 @@ public static <A> Stream<Option<A>> sequence(final Option<Stream<A>> o) {
    * @return A new stream after applying the given stream of functions through this stream.
    */
   public final <B> Stream<B> apply(final Stream<F<A, B>> sf) {
-    return sf.bind(f -> map(f));
+    return sf.bind(this::map);
   }
 
   /**
@@ -892,7 +893,7 @@ public final <B> Stream<P2<A, B>> zip(final Stream<B> bs) {
    * @return A new stream with the same length as this stream.
    */
   public final Stream<P2<A, Integer>> zipIndex() {
-    return zipWith(range(0), (a, i) -> p(a, i));
+    return zipWith(range(0), (F2<A, Integer, P2<A, Integer>>) P::p);
   }
 
   /**
@@ -941,7 +942,7 @@ public final A[] toJavaArray() {
    */
     public final List<A> toList() {
         List.Buffer<A> buf = List.Buffer.empty();
-        foreachDoEffect(a -> buf.snoc(a));
+        foreachDoEffect(buf::snoc);
         return buf.toList();
     }
 
@@ -1018,7 +1019,7 @@ public final Stream<A> cons(final A a) {
    */
   public static String asString(final Stream<Character> cs) {
     StringBuilder sb = new StringBuilder();
-    cs.foreachDoEffect(c -> sb.append(c));
+    cs.foreachDoEffect(sb::append);
     return sb.toString();
   }
 
@@ -1103,8 +1104,7 @@ public final Stream<A> takeWhile(final F<A, Boolean> f) {
   public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
     return this.foldRight1((a, acc) ->
             IOFunctions.bind(acc, (Stream<B> bs) ->
-                    IOFunctions.map(f.f(a), b ->
-                            bs.cons(b))), IOFunctions.unit(Stream.<B>nil()));
+                    IOFunctions.map(f.f(a), bs::cons)), IOFunctions.unit(Stream.<B>nil()));
 
   }
 
@@ -1114,7 +1114,7 @@ public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
    * @return traversed value
    */
   public final <B> Option<Stream<B>> traverseOption(F<A, Option<B>> f) {
-    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(b -> bs.cons(b))), some(Stream.<B>nil()));
+    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(bs::cons)), some(Stream.<B>nil()));
   }
 
   /**
@@ -1334,7 +1334,7 @@ public final Stream<Stream<A>> tails() {
    * @return a stream of the prefixes of this stream, starting with the stream itself.
    */
   public final Stream<Stream<A>> inits() {
-    final Stream<Stream<A>> nil = cons(Stream.<A>nil(), () -> nil());
+    final Stream<Stream<A>> nil = cons(Stream.<A>nil(), Stream::nil);
     return isEmpty() ? nil : nil.append(() -> tail()._1().inits().map(Stream.<A>cons_().f(head())));
   }
 
@@ -1344,7 +1344,7 @@ public final Stream<Stream<A>> inits() {
    * @return a stream of the infixes of this stream.
    */
   public final Stream<Stream<A>> substreams() {
-    return tails().bind(stream -> stream.inits());
+    return tails().bind(Stream::inits);
   }
 
   /**
@@ -1375,7 +1375,7 @@ public final <B> Stream<B> sequenceW(final Stream<F<Stream<A>, B>> fs) {
    * @return A function from natural numbers to values with the corresponding position in this stream.
    */
   public final F<Integer, A> toFunction() {
-    return i -> index(i);
+    return this::index;
   }
 
   /**
@@ -1426,7 +1426,7 @@ public static <A, B> P2<Stream<A>, Stream<B>> unzip(final Stream<P2<A, B>> xs) {
    * @return a function that zips two given streams with a given function.
    */
   public static <A, B, C> F<Stream<A>, F<Stream<B>, F<F<A, F<B, C>>, Stream<C>>>> zipWith() {
-    return curry((as, bs, f) -> as.zipWith(bs, f));
+    return curry((F3<Stream<A>, Stream<B>, F<A, F<B, C>>, Stream<C>>) Stream::zipWith);
   }
 
   private static final class Nil<A> extends Stream<A> {
@@ -1491,7 +1491,7 @@ public static <A> Stream<A> nil() {
    * @return An empty stream.
    */
   public static <A> P1<Stream<A>> nil_() {
-    return P.lazy(() -> new Nil<A>());
+    return P.lazy(Nil::new);
   }
 
   /**
@@ -1500,7 +1500,7 @@ public static <A> P1<Stream<A>> nil_() {
    * @return A function that determines whether a given stream is empty.
    */
   public static <A> F<Stream<A>, Boolean> isEmpty_() {
-    return as -> as.isEmpty();
+    return Stream::isEmpty;
   }
 
   /**
@@ -1509,7 +1509,7 @@ public static <A> F<Stream<A>, Boolean> isEmpty_() {
    * @return A function that determines whether a given stream is not empty.
    */
   public static <A> F<Stream<A>, Boolean> isNotEmpty_() {
-    return as -> as.isNotEmpty();
+    return Stream::isNotEmpty;
   }
 
   /**
@@ -1519,7 +1519,7 @@ public static <A> F<Stream<A>, Boolean> isNotEmpty_() {
    * @return A stream of one element containing the given value.
    */
   public static <A> Stream<A> single(final A a) {
-    return cons(a, () -> nil());
+    return cons(a, Stream::nil);
   }
 
   /**
@@ -1528,7 +1528,7 @@ public static <A> Stream<A> single(final A a) {
    * @return a function that yields a stream containing its argument.
    */
   public static <A> F<A, Stream<A>> single() {
-    return a -> single(a);
+    return Stream::single;
   }
 
   /**
@@ -1556,7 +1556,7 @@ public static <A> Stream<A> cons(final A head, final F0<Stream<A>> tail) {
    * @return A function that joins a stream of streams using a bind operation.
    */
   public static <A> F<Stream<Stream<A>>, Stream<A>> join() {
-    return as -> join(as);
+    return Stream::join;
   }
 
   /**
@@ -1651,7 +1651,7 @@ public static <A> Stream<A> iterate(final F<A, A> f, final A a) {
    *         starting at a given value.
    */
   public static <A> F<F<A, A>, F<A, Stream<A>>> iterate() {
-    return curry((f, a) -> iterate(f, a));
+    return curry(Stream::iterate);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index 004e0910..82e682bc 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -107,7 +107,7 @@ public P1<Stream<Tree<A>>> subForest() {
    * @return A transformation from a tree to its root.
    */
   public static <A> F<Tree<A>, A> root_() {
-    return a -> a.root();
+    return Tree::root;
   }
 
   /**
@@ -116,7 +116,7 @@ public static <A> F<Tree<A>, A> root_() {
    * @return A transformation from a tree to its subforest.
    */
   public static <A> F<Tree<A>, P1<Stream<Tree<A>>>> subForest_() {
-    return a -> a.subForest();
+    return Tree::subForest;
   }
 
   /**
@@ -142,7 +142,7 @@ public Stream<A> f(final Tree<A> t, final P1<Stream<A>> xs) {
    * @return The elements of the tree in pre-order.
    */
   public static <A> F<Tree<A>, Stream<A>> flatten_() {
-    return t -> t.flatten();
+    return Tree::flatten;
   }
 
   /**
@@ -335,7 +335,7 @@ public static <A, B> Tree<B> bottomUp(Tree<A> t, final F<P2<A, Stream<B>>, B> f)
     * @return a function getting the root of a Tree 
 	*/
    private static <A> F<Tree<A>, A> getRoot() {
-     return a -> a.root();
+     return Tree::root;
    }
 
     public boolean isLeaf() {
@@ -343,7 +343,7 @@ public boolean isLeaf() {
     }
 
     public int length() {
-        return 1 + subForest._1().map(t -> t.length()).foldLeft((acc, i) -> acc + i, 0);
+        return 1 + subForest._1().map(Tree::length).foldLeft((acc, i) -> acc + i, 0);
     }
 
 }
\ No newline at end of file
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index 2bdf70a9..de4876ec 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -264,7 +264,7 @@ public static <K, V> TreeMap<K, V> fromMutableMap(final Ord<K> ord, final Map<K,
    * @return a functional representation of this TreeMap.
    */
   public F<K, Option<V>> get() {
-    return k -> get(k);
+    return this::get;
   }
 
   /**
@@ -377,7 +377,7 @@ public Option<P2<K, V>> min() {
      * Returns the minimum key in the tree if the tree is not empty.
      */
     public Option<K> minKey() {
-        return tree.min().map(p -> p._1());
+        return tree.min().map(P2::_1);
     }
 
     /**
@@ -391,7 +391,7 @@ public Option<P2<K, V>> max() {
      * Returns the maximum key in the tree if the tree is not empty.
      */
     public Option<K> maxKey() {
-        return tree.max().map(p -> p._1());
+        return tree.max().map(P2::_1);
     }
 
   	/**
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index 959de5a7..3cfeff7c 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -81,7 +81,7 @@ public static <A> TreeZipper<A> treeZipper(final Tree<A> tree,
   F<Tree<A>, F<Stream<Tree<A>>, F<Stream<Tree<A>>, F<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>, TreeZipper<A>>>>>
   treeZipper() {
     return curry(
-            (tree, lefts, rights, parents) -> treeZipper(tree, lefts, rights, parents));
+        TreeZipper::treeZipper);
   }
 
   /**
@@ -100,7 +100,7 @@ public P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>,
    */
   public static <A>
   F<TreeZipper<A>, P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>>> p_() {
-    return a -> a.p();
+    return TreeZipper::p;
   }
 
   /**
@@ -167,7 +167,7 @@ public TreeZipper<A> root() {
    * @return A function that returns a new tree-zipper focused on the root of the given tree zipper's tree.
    */
   public static <A> F<TreeZipper<A>, TreeZipper<A>> root_() {
-    return a -> a.root();
+    return TreeZipper::root;
   }
 
   /**
@@ -553,7 +553,7 @@ public <B> TreeZipper<B> map(final F<A, B> f) {
    * @return A function that takes a tree to its tree zipper representation.
    */
   public static <A> F<Tree<A>, TreeZipper<A>> fromTree() {
-    return t -> fromTree(t);
+    return TreeZipper::fromTree;
   }
 
   /**
@@ -562,7 +562,7 @@ public static <A> F<Tree<A>, TreeZipper<A>> fromTree() {
    * @return A function that focuses the given tree zipper on its left sibling.
    */
   public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> left_() {
-    return z -> z.left();
+    return TreeZipper::left;
   }
 
   /**
@@ -571,7 +571,7 @@ public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> left_() {
    * @return A function that focuses the given tree zipper on its right sibling.
    */
   public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> right_() {
-    return z -> z.right();
+    return TreeZipper::right;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 3e622f68..8328590f 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -205,8 +205,8 @@ public <A> Validation<E, A> sequence(final Validation<E, A> v) {
    * all the failures using the semigroup, otherwise returns the successful list.
    */
   public static <E, A> Validation<E, List<A>> sequence(final Semigroup<E> s, final List<Validation<E, A>> list) {
-    if (list.exists(v -> v.isFail())) {
-      return Validation.<E, List<A>>fail(list.filter(v -> v.isFail()).map(v -> v.fail()).foldLeft1((e1, e2) -> s.sum(e1, e2)));
+    if (list.exists(Validation::isFail)) {
+      return Validation.<E, List<A>>fail(list.filter(Validation::isFail).map(v -> v.fail()).foldLeft1((F2<E, E, E>) s::sum));
     } else {
       return success(list.foldLeft((List<A> acc, Validation<E, A> v) -> acc.cons(v.success()), List.nil()).reverse());
     }
@@ -816,12 +816,12 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
    * single failure using a semigroup.
    */
     public static <A, E> Validation<List<E>, List<A>> sequenceNonCumulative(List<Validation<E, A>> list) {
-      if (list.exists(v -> v.isFail())) {
+      if (list.exists(Validation::isFail)) {
         F2<List<E>, Validation<E, A>, List<E>> f = (acc, v) -> acc.cons(v.fail());
-        return fail(list.filter(v -> v.isFail()).foldLeft(f, List.nil()).reverse());
+        return fail(list.filter(Validation::isFail).foldLeft(f, List.nil()).reverse());
       } else {
         F2<List<A>, Validation<E, A>, List<A>> f = (acc, v) -> acc.cons(v.success());
-        return success(list.filter(v -> v.isSuccess()).foldLeft(f, List.nil()).reverse());
+        return success(list.filter(Validation::isSuccess).foldLeft(f, List.nil()).reverse());
       }
     }
 
@@ -857,11 +857,11 @@ public <C> P1<Validation<E, C>> traverseP1(F<T, P1<C>> f){
 
 
     public static <A, E> List<E> fails(List<Validation<E, ?>> list) {
-        return list.filter(v -> v.isFail()).map(v -> v.fail());
+        return list.filter(Validation::isFail).map(v -> v.fail());
     }
 
     public static <A, E> List<A> successes(List<Validation<?, A>> list) {
-        return list.filter(v -> v.isSuccess()).map(v -> v.success());
+        return list.filter(Validation::isSuccess).map(v -> v.success());
     }
 
   /**
@@ -1002,7 +1002,7 @@ public <A> Option<Validation<E, A>> filter(final F<E, Boolean> f) {
      * @return The result of function application in validation.
      */
     public <A> Validation<A, T> apply(final Validation<F<E, A>, T> v) {
-      return v.f().bind(f -> map(f));
+      return v.f().bind(this::map);
     }
 
     /**
@@ -1103,7 +1103,7 @@ public static <E, T> Validation<E, T> validation(final Either<E, T> e) {
    * @return A function that constructs a validation with an either.
    */
   public static <E, T> F<Either<E, T>, Validation<E, T>> validation() {
-    return e1 -> validation(e1);
+    return Validation::validation;
   }
 
   /**
@@ -1112,7 +1112,7 @@ public static <E, T> F<Either<E, T>, Validation<E, T>> validation() {
    * @return A function that constructs an either with a validation.
    */
   public static <E, T> F<Validation<E, T>, Either<E, T>> either() {
-    return v -> v.toEither();
+    return Validation::toEither;
   }
 
   /**
@@ -1175,7 +1175,7 @@ public static Validation<NumberFormatException, Byte> parseByte(final String s)
   /**
    * A function that parses a string into a byte.
    */
-  public static final F<String, Validation<NumberFormatException, Byte>> parseByte = s -> parseByte(s);
+  public static final F<String, Validation<NumberFormatException, Byte>> parseByte = Validation::parseByte;
 
   /**
    * Parses the given string into a double.
@@ -1194,7 +1194,7 @@ public static Validation<NumberFormatException, Double> parseDouble(final String
   /**
    * A function that parses a string into a double.
    */
-  public static final F<String, Validation<NumberFormatException, Double>> parseDouble = s -> parseDouble(s);
+  public static final F<String, Validation<NumberFormatException, Double>> parseDouble = Validation::parseDouble;
 
   /**
    * Parses the given string into a float.
@@ -1213,7 +1213,7 @@ public static Validation<NumberFormatException, Float> parseFloat(final String s
   /**
    * A function that parses a string into a float.
    */
-  public static final F<String, Validation<NumberFormatException, Float>> parseFloat = s -> parseFloat(s);
+  public static final F<String, Validation<NumberFormatException, Float>> parseFloat = Validation::parseFloat;
 
   /**
    * Parses the given string into a integer.
@@ -1232,7 +1232,7 @@ public static Validation<NumberFormatException, Integer> parseInt(final String s
   /**
    * A function that parses a string into an integer.
    */
-  public static final F<String, Validation<NumberFormatException, Integer>> parseInt = s -> parseInt(s);
+  public static final F<String, Validation<NumberFormatException, Integer>> parseInt = Validation::parseInt;
 
   /**
    * Parses the given string into a long.
@@ -1251,7 +1251,7 @@ public static Validation<NumberFormatException, Long> parseLong(final String s)
   /**
    * A function that parses a string into a long.
    */
-  public static final F<String, Validation<NumberFormatException, Long>> parseLong = s -> parseLong(s);
+  public static final F<String, Validation<NumberFormatException, Long>> parseLong = Validation::parseLong;
 
   /**
    * Parses the given string into a short.
@@ -1270,15 +1270,15 @@ public static Validation<NumberFormatException, Short> parseShort(final String s
   /**
    * A function that parses a string into a short. 
    */
-  public static final F<String, Validation<NumberFormatException, Short>> parseShort = s -> parseShort(s);
+  public static final F<String, Validation<NumberFormatException, Short>> parseShort = Validation::parseShort;
 
   /**
    * Partitions the list into the list of fails and the list of successes
    */
   public static <A, B> P2<List<A>, List<B>> partition(List<Validation<A, B>> list) {
     return p(
-            list.filter(v -> v.isFail()).map(v -> v.fail()),
-            list.filter(v -> v.isSuccess()).map(v -> v.success())
+            list.filter(Validation::isFail).map(v -> v.fail()),
+            list.filter(Validation::isSuccess).map(v -> v.success())
     );
   }
 
diff --git a/core/src/main/java/fj/data/Zipper.java b/core/src/main/java/fj/data/Zipper.java
index 6de0d39c..f24ecf01 100644
--- a/core/src/main/java/fj/data/Zipper.java
+++ b/core/src/main/java/fj/data/Zipper.java
@@ -74,7 +74,7 @@ public static <A> Zipper<A> zipper(final P3<Stream<A>, A, Stream<A>> p) {
    * @return A function that yields a new zipper given streams on the left and right and a focus element.
    */
   public static <A> F3<Stream<A>, A, Stream<A>, Zipper<A>> zipper() {
-    return (l, a, r) -> zipper(l, a, r);
+    return Zipper::zipper;
   }
 
   /**
@@ -92,7 +92,7 @@ public P3<Stream<A>, A, Stream<A>> p() {
    * @return A first-class function that yields the product-3 representation of a given Zipper.
    */
   public static <A> F<Zipper<A>, P3<Stream<A>, A, Stream<A>>> p_() {
-    return a -> a.p();
+    return Zipper::p;
   }
 
   /**
@@ -255,7 +255,7 @@ public Zipper<A> tryPrevious() {
    * @return A function that moves the given zipper's focus to the next element.
    */
   public static <A> F<Zipper<A>, Option<Zipper<A>>> next_() {
-    return as -> as.next();
+    return Zipper::next;
   }
 
   /**
@@ -264,7 +264,7 @@ public static <A> F<Zipper<A>, Option<Zipper<A>>> next_() {
    * @return A function that moves the given zipper's focus to the previous element.
    */
   public static <A> F<Zipper<A>, Option<Zipper<A>>> previous_() {
-    return as -> as.previous();
+    return Zipper::previous;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
index debf2635..2b51f7a7 100644
--- a/core/src/main/java/fj/data/fingertrees/Digit.java
+++ b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -38,7 +38,7 @@ public abstract class Digit<V, A> {
    */
     public final A reduceRight(final F<A, F<A, A>> f) {
         return match(
-            one -> one.value(),
+            One::value,
             two -> {
                 final V2<A> v = two.values();
                 return f.f(v._1()).f(v._2());
@@ -62,7 +62,7 @@ public final A reduceRight(final F<A, F<A, A>> f) {
    */
   public final A reduceLeft(final F<A, F<A, A>> f) {
     return match(
-        one -> one.value(),
+        One::value,
         two -> {
             final V2<A> v = two.values();
             return f.f(v._1()).f(v._2());
diff --git a/core/src/main/java/fj/data/fingertrees/Measured.java b/core/src/main/java/fj/data/fingertrees/Measured.java
index 777eb369..d33b5726 100644
--- a/core/src/main/java/fj/data/fingertrees/Measured.java
+++ b/core/src/main/java/fj/data/fingertrees/Measured.java
@@ -74,7 +74,7 @@ public V zero() {
    * @return A measured instance for nodes.
    */
   public Measured<V, Node<V, A>> nodeMeasured() {
-    return new Measured<V, Node<V, A>>(m, node -> node.measure());
+    return new Measured<V, Node<V, A>>(m, Node::measure);
   }
 
   /**
@@ -83,7 +83,7 @@ public Measured<V, Node<V, A>> nodeMeasured() {
    * @return A measured instance for digits.
    */
   public Measured<V, Digit<V, A>> digitMeasured() {
-    return new Measured<V, Digit<V, A>>(m, d -> d.measure());
+    return new Measured<V, Digit<V, A>>(m, Digit::measure);
   }
 
 }
diff --git a/core/src/main/java/fj/data/optic/POptional.java b/core/src/main/java/fj/data/optic/POptional.java
index 92e4edf0..5c0bdd8c 100644
--- a/core/src/main/java/fj/data/optic/POptional.java
+++ b/core/src/main/java/fj/data/optic/POptional.java
@@ -458,7 +458,7 @@ public F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
       @Override
       public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
         return s -> getOrModify.f(s).either(
-            t -> Validation.<E, T> success(t),
+            Validation::<E, T>success,
             t -> f.f(t).map(b -> set.f(b).f(s))
             );
       }
diff --git a/core/src/main/java/fj/data/optic/PPrism.java b/core/src/main/java/fj/data/optic/PPrism.java
index 476758a7..f6712989 100644
--- a/core/src/main/java/fj/data/optic/PPrism.java
+++ b/core/src/main/java/fj/data/optic/PPrism.java
@@ -126,7 +126,7 @@ public final F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
   /** modify polymorphically the target of a {@link PPrism} with an Applicative function */
   public final <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
     return s -> getOrModify(s).either(
-        t -> Validation.<E, T> success(t),
+        Validation::<E, T>success,
         t -> f.f(t).map(this::reverseGet)
         );
   }
diff --git a/core/src/main/java/fj/data/vector/V.java b/core/src/main/java/fj/data/vector/V.java
index 26a86462..57249ac8 100644
--- a/core/src/main/java/fj/data/vector/V.java
+++ b/core/src/main/java/fj/data/vector/V.java
@@ -35,7 +35,7 @@ public static <A> V2<A> v(final A a1, final A a2) {
    * @return The vector-2.
    */
   public static <A> V2<A> v(final F0<A> a1, final F0<A> a2) {
-      return V2.p(P.lazy(() -> a1.f(), () -> a2.f()));
+      return V2.p(P.lazy(a1::f, a2::f));
   }
 
   /**
@@ -44,7 +44,7 @@ public static <A> V2<A> v(final F0<A> a1, final F0<A> a2) {
    * @return A function that puts elements in a vector-2.
    */
   public static <A> F2<A, A, V2<A>> v2() {
-    return (a, a1) -> v(a, a1);
+    return V::v;
   }
 
   /**
@@ -77,7 +77,7 @@ public static <A> V3<A> v(final P1<A> a1, final F0<A> a2, final F0<A> a3) {
    * @return A function that puts elements in a vector-3.
    */
   public static <A> F3<A, A, A, V3<A>> v3() {
-    return (a, a1, a2) -> v(a, a1, a2);
+    return V::v;
   }
 
   /**
@@ -112,7 +112,7 @@ public static <A> V4<A> v(final P1<A> a1, final P1<A> a2, final F0<A> a3, final
    * @return A function that puts elements in a vector-4.
    */
   public static <A> F4<A, A, A, A, V4<A>> v4() {
-    return (a, a1, a2, a3) -> v(a, a1, a2, a3);
+    return V::v;
   }
 
 
@@ -150,7 +150,7 @@ public static <A> V5<A> v(final P1<A> a1, final P1<A> a2, final P1<A> a3, final
    * @return A function that puts elements in a vector-5.
    */
   public static <A> F5<A, A, A, A, A, V5<A>> v5() {
-    return (a, a1, a2, a3, a4) -> v(a, a1, a2, a3, a4);
+    return V::v;
   }
 
 }
diff --git a/core/src/main/java/fj/data/vector/V2.java b/core/src/main/java/fj/data/vector/V2.java
index e5bf7bc1..700a8409 100644
--- a/core/src/main/java/fj/data/vector/V2.java
+++ b/core/src/main/java/fj/data/vector/V2.java
@@ -57,7 +57,7 @@ public A _2() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V2<A>, A> __1() {
-    return v -> v._1();
+    return V2::_1;
   }
 
   /**
@@ -66,7 +66,7 @@ public static <A> F<V2<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V2<A>, A> __2() {
-    return v -> v._2();
+    return V2::_2;
   }
 
   /**
@@ -111,7 +111,7 @@ public Stream<A> toStream() {
    * @return a function that transforms a vector-2 to a stream of its elements.
    */
   public static <A> F<V2<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V2::toStream;
   }
 
   /**
@@ -120,7 +120,7 @@ public static <A> F<V2<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-2 to the equivalent product-2.
    */
   public static <A> F<V2<A>, P2<A, A>> p_() {
-    return v -> v.p();
+    return V2::p;
   }
 
   /**
@@ -193,7 +193,7 @@ public V2<V2<A>> vzip(final V2<A> bs) {
    * @return the first element of this vector as a product-1.
    */
   public P1<A> head() {
-    return P.lazy(() -> V2.this._1());
+    return P.lazy(V2.this::_1);
   }
 
 }
diff --git a/core/src/main/java/fj/data/vector/V3.java b/core/src/main/java/fj/data/vector/V3.java
index 22e11946..ceb492bc 100644
--- a/core/src/main/java/fj/data/vector/V3.java
+++ b/core/src/main/java/fj/data/vector/V3.java
@@ -31,8 +31,8 @@ private V3(final P1<A> head, final V2<A> tail) {
    */
   public static <A> V3<A> p(final P3<A, A, A> p) {
     return new V3<A>(
-        P.lazy(() -> p._1()),
-        V2.p(P.lazy(() -> p._2(), () -> p._3()))
+        P.lazy(p::_1),
+        V2.p(P.lazy(p::_2, p::_3))
     );
   }
 
@@ -211,7 +211,7 @@ public <B> V3<B> map(final F<A, B> f) {
    * @return a function that transforms a vector-3 to a stream of its elements.
    */
   public static <A> F<V3<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V3::toStream;
   }
 
   /**
@@ -220,7 +220,7 @@ public static <A> F<V3<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-3 to the equivalent product-3.
    */
   public static <A> F<V3<A>, P3<A, A, A>> p_() {
-    return v -> v.p();
+    return V3::p;
   }
 
   /**
@@ -229,7 +229,7 @@ public static <A> F<V3<A>, P3<A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V3<A>, A> __1() {
-    return v -> v._1();
+    return V3::_1;
   }
 
   /**
@@ -238,7 +238,7 @@ public static <A> F<V3<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V3<A>, A> __2() {
-    return v -> v._2();
+    return V3::_2;
   }
 
   /**
@@ -247,7 +247,7 @@ public static <A> F<V3<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V3<A>, A> __3() {
-    return v -> v._3();
+    return V3::_3;
   }
 
 }
\ No newline at end of file
diff --git a/core/src/main/java/fj/data/vector/V4.java b/core/src/main/java/fj/data/vector/V4.java
index 19ea2648..8e142023 100644
--- a/core/src/main/java/fj/data/vector/V4.java
+++ b/core/src/main/java/fj/data/vector/V4.java
@@ -30,7 +30,7 @@ private V4(final P1<A> head, final V3<A> tail) {
    * @return A new vector-4.
    */
   public static <A> V4<A> p(final P4<A, A, A, A> p) {
-    return new V4<A>(P.lazy(() -> p._1()),
+    return new V4<A>(P.lazy(p::_1),
     V3.p(new P3<A, A, A>() {
       public A _1() {
         return p._2();
@@ -160,7 +160,7 @@ public NonEmptyList<A> toNonEmptyList() {
    * @return a stream of the elements of this vector.
    */
   public Stream<A> toStream() {
-    return Stream.cons(head._1(), () -> tail.toStream());
+    return Stream.cons(head._1(), tail::toStream);
   }
 
   /**
@@ -233,7 +233,7 @@ public V4<V2<A>> vzip(final V4<A> bs) {
    * @return a function that transforms a vector-4 to a stream of its elements.
    */
   public static <A> F<V4<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V4::toStream;
   }
 
   /**
@@ -242,7 +242,7 @@ public static <A> F<V4<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-4 to the equivalent product-4.
    */
   public static <A> F<V4<A>, P4<A, A, A, A>> p_() {
-    return v -> v.p();
+    return V4::p;
   }
 
   /**
@@ -251,7 +251,7 @@ public static <A> F<V4<A>, P4<A, A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V4<A>, A> __1() {
-    return v -> v._1();
+    return V4::_1;
   }
 
   /**
@@ -260,7 +260,7 @@ public static <A> F<V4<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V4<A>, A> __2() {
-    return v -> v._2();
+    return V4::_2;
   }
 
   /**
@@ -269,7 +269,7 @@ public static <A> F<V4<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V4<A>, A> __3() {
-    return v -> v._3();
+    return V4::_3;
   }
 
   /**
@@ -278,6 +278,6 @@ public static <A> F<V4<A>, A> __3() {
    * @return a function that gets the fourth element of a given vector.
    */
   public static <A> F<V4<A>, A> __4() {
-    return v -> v._4();
+    return V4::_4;
   }
 }
diff --git a/core/src/main/java/fj/data/vector/V5.java b/core/src/main/java/fj/data/vector/V5.java
index 3aab13e3..d386cb32 100644
--- a/core/src/main/java/fj/data/vector/V5.java
+++ b/core/src/main/java/fj/data/vector/V5.java
@@ -30,7 +30,7 @@ private V5(final P1<A> head, final V4<A> tail) {
    * @return A new vector-5.
    */
   public static <A> V5<A> p(final P5<A, A, A, A, A> p) {
-    return new V5<A>(P.lazy(() -> p._1()),
+    return new V5<A>(P.lazy(p::_1),
     V4.p(new P4<A, A, A, A>() {
       public A _1() {
         return p._2();
@@ -177,7 +177,7 @@ public NonEmptyList<A> toNonEmptyList() {
    * @return a stream of the elements of this vector.
    */
   public Stream<A> toStream() {
-    return Stream.cons(head._1(), () -> tail.toStream());
+    return Stream.cons(head._1(), tail::toStream);
   }
 
   /**
@@ -250,7 +250,7 @@ public V5<V2<A>> vzip(final V5<A> bs) {
    * @return a function that transforms a vector-5 to a stream of its elements.
    */
   public static <A> F<V5<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V5::toStream;
   }
 
   /**
@@ -259,7 +259,7 @@ public static <A> F<V5<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-5 to the equivalent product-5.
    */
   public static <A> F<V5<A>, P5<A, A, A, A, A>> p_() {
-    return v -> v.p();
+    return V5::p;
   }
 
   /**
@@ -268,7 +268,7 @@ public static <A> F<V5<A>, P5<A, A, A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V5<A>, A> __1() {
-    return v -> v._1();
+    return V5::_1;
   }
 
   /**
@@ -277,7 +277,7 @@ public static <A> F<V5<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V5<A>, A> __2() {
-    return v -> v._2();
+    return V5::_2;
   }
 
   /**
@@ -286,7 +286,7 @@ public static <A> F<V5<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V5<A>, A> __3() {
-    return v -> v._3();
+    return V5::_3;
   }
 
   /**
@@ -295,7 +295,7 @@ public static <A> F<V5<A>, A> __3() {
    * @return a function that gets the fourth element of a given vector.
    */
   public static <A> F<V5<A>, A> __4() {
-    return v -> v._4();
+    return V5::_4;
   }
 
   /**
@@ -304,6 +304,6 @@ public static <A> F<V5<A>, A> __4() {
    * @return a function that gets the fifth element of a given vector.
    */
   public static <A> F<V5<A>, A> __5() {
-    return v -> v._5();
+    return V5::_5;
   }
 }
diff --git a/core/src/main/java/fj/data/vector/V6.java b/core/src/main/java/fj/data/vector/V6.java
index 66a5afca..107c01a5 100644
--- a/core/src/main/java/fj/data/vector/V6.java
+++ b/core/src/main/java/fj/data/vector/V6.java
@@ -30,7 +30,7 @@ private V6(final P1<A> head, final V5<A> tail) {
    * @return A new vector-6.
    */
   public static <A> V6<A> p(final P6<A, A, A, A, A, A> p) {
-    return new V6<A>(P.lazy(() -> p._1()),
+    return new V6<A>(P.lazy(p::_1),
     V5.p(new P5<A, A, A, A, A>() {
       public A _1() {
         return p._2();
@@ -194,7 +194,7 @@ public NonEmptyList<A> toNonEmptyList() {
    * @return a stream of the elements of this vector.
    */
   public Stream<A> toStream() {
-    return Stream.cons(head._1(), () -> tail.toStream());
+    return Stream.cons(head._1(), tail::toStream);
   }
 
   /**
@@ -267,7 +267,7 @@ public V6<V2<A>> vzip(final V6<A> bs) {
    * @return a function that transforms a vector-6 to a stream of its elements.
    */
   public static <A> F<V6<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V6::toStream;
   }
 
   /**
@@ -276,7 +276,7 @@ public static <A> F<V6<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-6 to the equivalent product-6.
    */
   public static <A> F<V6<A>, P6<A, A, A, A, A, A>> p_() {
-    return v -> v.p();
+    return V6::p;
   }
 
   /**
@@ -285,7 +285,7 @@ public static <A> F<V6<A>, P6<A, A, A, A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V6<A>, A> __1() {
-    return v -> v._1();
+    return V6::_1;
   }
 
   /**
@@ -294,7 +294,7 @@ public static <A> F<V6<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V6<A>, A> __2() {
-    return v -> v._2();
+    return V6::_2;
   }
 
   /**
@@ -303,7 +303,7 @@ public static <A> F<V6<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V6<A>, A> __3() {
-    return v -> v._3();
+    return V6::_3;
   }
 
   /**
@@ -312,7 +312,7 @@ public static <A> F<V6<A>, A> __3() {
    * @return a function that gets the fourth element of a given vector.
    */
   public static <A> F<V6<A>, A> __4() {
-    return v -> v._4();
+    return V6::_4;
   }
 
   /**
@@ -321,7 +321,7 @@ public static <A> F<V6<A>, A> __4() {
    * @return a function that gets the fifth element of a given vector.
    */
   public static <A> F<V6<A>, A> __5() {
-    return v -> v._5();
+    return V6::_5;
   }
 
   /**
@@ -330,7 +330,7 @@ public static <A> F<V6<A>, A> __5() {
    * @return a function that gets the sixth element of a given vector.
    */
   public static <A> F<V6<A>, A> __6() {
-    return v -> v._6();
+    return V6::_6;
   }
 
 }
diff --git a/core/src/main/java/fj/data/vector/V7.java b/core/src/main/java/fj/data/vector/V7.java
index c57e3551..52699481 100644
--- a/core/src/main/java/fj/data/vector/V7.java
+++ b/core/src/main/java/fj/data/vector/V7.java
@@ -30,7 +30,7 @@ private V7(final P1<A> head, final V6<A> tail) {
    * @return A new vector-7.
    */
   public static <A> V7<A> p(final P7<A, A, A, A, A, A, A> p) {
-    return new V7<A>(P.lazy(() -> p._1()),
+    return new V7<A>(P.lazy(p::_1),
     V6.p(new P6<A, A, A, A, A, A>() {
       public A _1() {
         return p._2();
@@ -211,7 +211,7 @@ public NonEmptyList<A> toNonEmptyList() {
    * @return a stream of the elements of this vector.
    */
   public Stream<A> toStream() {
-    return Stream.cons(head._1(), () -> tail.toStream());
+    return Stream.cons(head._1(), tail::toStream);
   }
 
   /**
@@ -284,7 +284,7 @@ public V7<V2<A>> vzip(final V7<A> bs) {
    * @return a function that transforms a vector-7 to a stream of its elements.
    */
   public static <A> F<V7<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V7::toStream;
   }
 
   /**
@@ -293,7 +293,7 @@ public static <A> F<V7<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-7 to the equivalent product-7.
    */
   public static <A> F<V7<A>, P7<A, A, A, A, A, A, A>> p_() {
-    return v -> v.p();
+    return V7::p;
   }
 
   /**
@@ -302,7 +302,7 @@ public static <A> F<V7<A>, P7<A, A, A, A, A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V7<A>, A> __1() {
-    return v -> v._1();
+    return V7::_1;
   }
 
   /**
@@ -311,7 +311,7 @@ public static <A> F<V7<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V7<A>, A> __2() {
-    return v -> v._2();
+    return V7::_2;
   }
 
   /**
@@ -320,7 +320,7 @@ public static <A> F<V7<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V7<A>, A> __3() {
-    return v -> v._3();
+    return V7::_3;
   }
 
   /**
@@ -329,7 +329,7 @@ public static <A> F<V7<A>, A> __3() {
    * @return a function that gets the fourth element of a given vector.
    */
   public static <A> F<V7<A>, A> __4() {
-    return v -> v._4();
+    return V7::_4;
   }
 
   /**
@@ -338,7 +338,7 @@ public static <A> F<V7<A>, A> __4() {
    * @return a function that gets the fifth element of a given vector.
    */
   public static <A> F<V7<A>, A> __5() {
-    return v -> v._5();
+    return V7::_5;
   }
 
   /**
@@ -347,7 +347,7 @@ public static <A> F<V7<A>, A> __5() {
    * @return a function that gets the sixth element of a given vector.
    */
   public static <A> F<V7<A>, A> __6() {
-    return v -> v._6();
+    return V7::_6;
   }
 
   /**
@@ -356,7 +356,7 @@ public static <A> F<V7<A>, A> __6() {
    * @return a function that gets the seventh element of a given vector.
    */
   public static <A> F<V7<A>, A> __7() {
-    return v -> v._7();
+    return V7::_7;
   }
 
 }
diff --git a/core/src/main/java/fj/data/vector/V8.java b/core/src/main/java/fj/data/vector/V8.java
index 72af03f1..8ad96cdd 100644
--- a/core/src/main/java/fj/data/vector/V8.java
+++ b/core/src/main/java/fj/data/vector/V8.java
@@ -30,7 +30,7 @@ private V8(final P1<A> head, final V7<A> tail) {
    * @return A new vector-8.
    */
   public static <A> V8<A> p(final P8<A, A, A, A, A, A, A, A> p) {
-    return new V8<A>(P.lazy(() -> p._1()),
+    return new V8<A>(P.lazy(p::_1),
     V7.p(new P7<A, A, A, A, A, A, A>() {
       public A _1() {
         return p._2();
@@ -228,7 +228,7 @@ public NonEmptyList<A> toNonEmptyList() {
    * @return a stream of the elements of this vector.
    */
   public Stream<A> toStream() {
-    return Stream.cons(head._1(), () -> tail.toStream());
+    return Stream.cons(head._1(), tail::toStream);
   }
 
   /**
@@ -301,7 +301,7 @@ public V8<V2<A>> vzip(final V8<A> bs) {
    * @return a function that transforms a vector-8 to a stream of its elements.
    */
   public static <A> F<V8<A>, Stream<A>> toStream_() {
-    return v -> v.toStream();
+    return V8::toStream;
   }
 
   /**
@@ -310,7 +310,7 @@ public static <A> F<V8<A>, Stream<A>> toStream_() {
    * @return a function that transforms a vector-8 to the equivalent product-8.
    */
   public static <A> F<V8<A>, P8<A, A, A, A, A, A, A, A>> p_() {
-    return v -> v.p();
+    return V8::p;
   }
 
 
@@ -320,7 +320,7 @@ public static <A> F<V8<A>, P8<A, A, A, A, A, A, A, A>> p_() {
    * @return a function that gets the first element of a given vector.
    */
   public static <A> F<V8<A>, A> __1() {
-    return v -> v._1();
+    return V8::_1;
   }
 
   /**
@@ -329,7 +329,7 @@ public static <A> F<V8<A>, A> __1() {
    * @return a function that gets the second element of a given vector.
    */
   public static <A> F<V8<A>, A> __2() {
-    return v -> v._2();
+    return V8::_2;
   }
 
   /**
@@ -338,7 +338,7 @@ public static <A> F<V8<A>, A> __2() {
    * @return a function that gets the third element of a given vector.
    */
   public static <A> F<V8<A>, A> __3() {
-    return v -> v._3();
+    return V8::_3;
   }
 
   /**
@@ -347,7 +347,7 @@ public static <A> F<V8<A>, A> __3() {
    * @return a function that gets the fourth element of a given vector.
    */
   public static <A> F<V8<A>, A> __4() {
-    return v -> v._4();
+    return V8::_4;
   }
 
   /**
@@ -356,7 +356,7 @@ public static <A> F<V8<A>, A> __4() {
    * @return a function that gets the fifth element of a given vector.
    */
   public static <A> F<V8<A>, A> __5() {
-    return v -> v._5();
+    return V8::_5;
   }
 
   /**
@@ -365,7 +365,7 @@ public static <A> F<V8<A>, A> __5() {
    * @return a function that gets the sixth element of a given vector.
    */
   public static <A> F<V8<A>, A> __6() {
-    return v -> v._6();
+    return V8::_6;
   }
 
   /**
@@ -374,7 +374,7 @@ public static <A> F<V8<A>, A> __6() {
    * @return a function that gets the seventh element of a given vector.
    */
   public static <A> F<V8<A>, A> __7() {
-    return v -> v._7();
+    return V8::_7;
   }
 
   /**
@@ -383,7 +383,7 @@ public static <A> F<V8<A>, A> __7() {
    * @return a function that gets the eighth element of a given vector.
    */
   public static <A> F<V8<A>, A> __8() {
-    return v -> v._8();
+    return V8::_8;
   }
 
 }
diff --git a/core/src/main/java/fj/function/BigIntegers.java b/core/src/main/java/fj/function/BigIntegers.java
index 97f1a520..30d07a10 100644
--- a/core/src/main/java/fj/function/BigIntegers.java
+++ b/core/src/main/java/fj/function/BigIntegers.java
@@ -1,6 +1,7 @@
 package fj.function;
 
 import fj.F;
+import fj.F2;
 import fj.Monoid;
 import fj.data.List;
 import static fj.Function.curry;
@@ -21,40 +22,40 @@ private BigIntegers() {
    * Curried Integer addition.
    */
   public static final F<BigInteger, F<BigInteger, BigInteger>> add =
-      curry((a1, a2) -> a1.add(a2));
+      curry((F2<BigInteger, BigInteger, BigInteger>) BigInteger::add);
 
   /**
    * Curried Integer multiplication.
    */
   public static final F<BigInteger, F<BigInteger, BigInteger>> multiply =
-      curry((a1, a2) -> a1.multiply(a2));
+      curry(BigInteger::multiply);
 
   /**
    * Curried Integer subtraction.
    */
   public static final F<BigInteger, F<BigInteger, BigInteger>> subtract =
-      curry((a1, a2) -> a1.subtract(a2));
+      curry((F2<BigInteger, BigInteger, BigInteger>) BigInteger::subtract);
 
   /**
    * Negation.
    */
-  public static final F<BigInteger, BigInteger> negate = i -> i.negate();
+  public static final F<BigInteger, BigInteger> negate = BigInteger::negate;
 
   /**
    * Absolute value.
    */
-  public static final F<BigInteger, BigInteger> abs = i -> i.abs();
+  public static final F<BigInteger, BigInteger> abs = BigInteger::abs;
 
   /**
    * Remainder.
    */
   public static final F<BigInteger, F<BigInteger, BigInteger>> remainder =
-      curry((a1, a2) -> a1.remainder(a2));
+      curry(BigInteger::remainder);
 
   /**
    * Power.
    */
-  public static final F<BigInteger, F<Integer, BigInteger>> power = curry((a1, a2) -> a1.pow(a2));
+  public static final F<BigInteger, F<Integer, BigInteger>> power = curry(BigInteger::pow);
 
   /**
    * Sums a list of big integers.
diff --git a/core/src/main/java/fj/function/Characters.java b/core/src/main/java/fj/function/Characters.java
index 9191bd5a..220bea7a 100644
--- a/core/src/main/java/fj/function/Characters.java
+++ b/core/src/main/java/fj/function/Characters.java
@@ -12,30 +12,30 @@ private Characters() {
     throw new UnsupportedOperationException();
   }
   public static final F<Character, String> toString = c -> Character.toString(c);
-  public static final F<Character, Boolean> isLowerCase = ch -> Character.isLowerCase(ch);
-  public static final F<Character, Boolean> isUpperCase = ch -> Character.isUpperCase(ch);
-  public static final F<Character, Boolean> isTitleCase = ch -> Character.isTitleCase(ch);
-  public static final F<Character, Boolean> isDigit = ch -> Character.isDigit(ch);
-  public static final F<Character, Boolean> isDefined = ch -> Character.isDefined(ch);
-  public static final F<Character, Boolean> isLetter = ch -> Character.isLetter(ch);
-  public static final F<Character, Boolean> isLetterOrDigit = ch -> Character.isLetterOrDigit(ch);
-  public static final F<Character, Boolean> isJavaIdentifierStart = ch -> Character.isJavaIdentifierStart(ch);
-  public static final F<Character, Boolean> isJavaIdentifierPart = ch -> Character.isJavaIdentifierPart(ch);
-  public static final F<Character, Boolean> isUnicodeIdentifierStart = ch -> Character.isUnicodeIdentifierStart(ch);
-  public static final F<Character, Boolean> isUnicodeIdentifierPart = ch -> Character.isUnicodeIdentifierPart(ch);
-  public static final F<Character, Boolean> isIdentifierIgnorable = ch -> Character.isIdentifierIgnorable(ch);
-  public static final F<Character, Character> toLowerCase = ch -> Character.toLowerCase(ch);
-  public static final F<Character, Character> toUpperCase = ch -> Character.toUpperCase(ch);
-  public static final F<Character, Character> toTitleCase = ch -> Character.toTitleCase(ch);
+  public static final F<Character, Boolean> isLowerCase = Character::isLowerCase;
+  public static final F<Character, Boolean> isUpperCase = Character::isUpperCase;
+  public static final F<Character, Boolean> isTitleCase = Character::isTitleCase;
+  public static final F<Character, Boolean> isDigit = Character::isDigit;
+  public static final F<Character, Boolean> isDefined = Character::isDefined;
+  public static final F<Character, Boolean> isLetter = Character::isLetter;
+  public static final F<Character, Boolean> isLetterOrDigit = Character::isLetterOrDigit;
+  public static final F<Character, Boolean> isJavaIdentifierStart = Character::isJavaIdentifierStart;
+  public static final F<Character, Boolean> isJavaIdentifierPart = Character::isJavaIdentifierPart;
+  public static final F<Character, Boolean> isUnicodeIdentifierStart = Character::isUnicodeIdentifierStart;
+  public static final F<Character, Boolean> isUnicodeIdentifierPart = Character::isUnicodeIdentifierPart;
+  public static final F<Character, Boolean> isIdentifierIgnorable = Character::isIdentifierIgnorable;
+  public static final F<Character, Character> toLowerCase = Character::toLowerCase;
+  public static final F<Character, Character> toUpperCase = Character::toUpperCase;
+  public static final F<Character, Character> toTitleCase = Character::toTitleCase;
   public static final F<Character, F<Integer, Integer>> digit = curry((ch, radix) -> Character.digit(ch, radix));
-  public static final F<Character, Integer> getNumericValue = ch -> Character.getNumericValue(ch);
-  public static final F<Character, Boolean> isSpaceChar = ch -> Character.isSpaceChar(ch);
-  public static final F<Character, Boolean> isWhitespace = ch -> Character.isWhitespace(ch);
-  public static final F<Character, Boolean> isISOControl = ch -> Character.isISOControl(ch);
-  public static final F<Character, Integer> getType = ch -> Character.getType(ch);
-  public static final F<Character, Byte> getDirectionality = ch -> Character.getDirectionality(ch);
-  public static final F<Character, Boolean> isMirrored = ch -> Character.isMirrored(ch);
-  public static final F<Character, Character> reverseBytes = ch -> Character.reverseBytes(ch);
+  public static final F<Character, Integer> getNumericValue = Character::getNumericValue;
+  public static final F<Character, Boolean> isSpaceChar = Character::isSpaceChar;
+  public static final F<Character, Boolean> isWhitespace = Character::isWhitespace;
+  public static final F<Character, Boolean> isISOControl = Character::isISOControl;
+  public static final F<Character, Integer> getType = Character::getType;
+  public static final F<Character, Byte> getDirectionality = Character::getDirectionality;
+  public static final F<Character, Boolean> isMirrored = Character::isMirrored;
+  public static final F<Character, Character> reverseBytes = Character::reverseBytes;
   public static final F<Character, Boolean> isNewLine = c -> c == '\n';
 
 }
diff --git a/core/src/main/java/fj/function/Doubles.java b/core/src/main/java/fj/function/Doubles.java
index 1a85a100..7bff2409 100644
--- a/core/src/main/java/fj/function/Doubles.java
+++ b/core/src/main/java/fj/function/Doubles.java
@@ -45,7 +45,7 @@ private Doubles() {
   /**
    * Absolute value.
    */
-  public static final F<Double, Double> abs = x -> abs(x);
+  public static final F<Double, Double> abs = Math::abs;
 
   /**
    * Remainder.
@@ -55,7 +55,7 @@ private Doubles() {
   /**
    * Power.
    */
-  public static final F<Double, F<Double, Double>> power = curry((a, b) -> StrictMath.pow(a, b));
+  public static final F<Double, F<Double, Double>> power = curry(StrictMath::pow);
 
   /**
    * Evenness.
diff --git a/core/src/main/java/fj/function/Integers.java b/core/src/main/java/fj/function/Integers.java
index c51359e4..4b1b14b5 100644
--- a/core/src/main/java/fj/function/Integers.java
+++ b/core/src/main/java/fj/function/Integers.java
@@ -47,7 +47,7 @@ private Integers() {
   /**
    * Absolute value.
    */
-  public static final F<Integer, Integer> abs = x -> abs(x);
+  public static final F<Integer, Integer> abs = Math::abs;
 
   /**
    * Remainder.
diff --git a/core/src/main/java/fj/function/Longs.java b/core/src/main/java/fj/function/Longs.java
index a1bd60eb..18667699 100644
--- a/core/src/main/java/fj/function/Longs.java
+++ b/core/src/main/java/fj/function/Longs.java
@@ -41,7 +41,7 @@ private Longs() {
   /**
    * Absolute value.
    */
-  public static final F<Long, Long> abs = x -> abs(x);
+  public static final F<Long, Long> abs = Math::abs;
 
   /**
    * Remainder.
diff --git a/core/src/main/java/fj/function/Strings.java b/core/src/main/java/fj/function/Strings.java
index 88e9cc2f..c64db043 100644
--- a/core/src/main/java/fj/function/Strings.java
+++ b/core/src/main/java/fj/function/Strings.java
@@ -61,7 +61,7 @@ private Strings() {
   /**
    * A curried version of {@link String#length()}.
    */
-  public static final F<String, Integer> length = s -> s.length();
+  public static final F<String, Integer> length = String::length;
 
   /**
    * A curried version of {@link String#contains(CharSequence)}.
@@ -80,17 +80,17 @@ public static List<String> lines(String s) {
   }
 
   public static F<String, List<String>> lines() {
-    return s -> lines(s);
+    return Strings::lines;
   }
 
   public static String unlines(List<String> list) {
     StringBuilder sb = new StringBuilder();
-    list.intersperse(lineSeparator).foreachDoEffect(s -> sb.append(s));
+    list.intersperse(lineSeparator).foreachDoEffect(sb::append);
     return sb.toString();
   }
 
   public static F<List<String>, String> unlines() {
-    return l -> unlines(l);
+    return Strings::unlines;
   }
 
 }
diff --git a/core/src/main/java/fj/parser/Parser.java b/core/src/main/java/fj/parser/Parser.java
index e5ce04c9..605125f0 100644
--- a/core/src/main/java/fj/parser/Parser.java
+++ b/core/src/main/java/fj/parser/Parser.java
@@ -210,7 +210,7 @@ public <B> Parser<I, B, E> sequence(final Parser<I, B, E> p) {
    * @return A new parser after function application.
    */
   public <B> Parser<I, B, E> apply(final Parser<I, F<A, B>, E> p) {
-    return p.bind((F<F<A, B>, Parser<I, B, E>>) f1 -> map(f1));
+    return p.bind((F<F<A, B>, Parser<I, B, E>>) this::map);
   }
 
   /**
@@ -549,7 +549,7 @@ public static <E> Parser<Stream<Character>, String, E> string(final E missing, f
      * @return A parser that produces a digit (0 to 9).
      */
     public static <E> Parser<Stream<Character>, Digit, E> digit(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isDigit(c)).map(c1 -> Digit.fromChar(c1).some());
+      return StreamParser.satisfy(missing, sat, Character::isDigit).map(c1 -> Digit.fromChar(c1).some());
     }
 
     /**
@@ -572,7 +572,7 @@ public static <E> Parser<Stream<Character>, Digit, E> digit(final E missing, fin
      * @see Character#isLowerCase(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> lower(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isLowerCase(c));
+      return StreamParser.satisfy(missing, sat, Character::isLowerCase);
     }
 
     /**
@@ -596,7 +596,7 @@ public static <E> Parser<Stream<Character>, Character, E> lower(final E missing,
      * @see Character#isUpperCase(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> upper(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isUpperCase(c));
+      return StreamParser.satisfy(missing, sat, Character::isUpperCase);
     }
 
     /**
@@ -620,7 +620,7 @@ public static <E> Parser<Stream<Character>, Character, E> upper(final E missing,
      * @see Character#isDefined(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> defined(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isDefined(c));
+      return StreamParser.satisfy(missing, sat, Character::isDefined);
     }
 
     /**
@@ -645,7 +645,7 @@ public static <E> Parser<Stream<Character>, Character, E> defined(final E missin
      */
     public static <E> Parser<Stream<Character>, Character, E> highSurrogate(final F0<E> missing,
                                                                             final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isHighSurrogate(c));
+      return StreamParser.satisfy(missing, sat, Character::isHighSurrogate);
     }
 
     /**
@@ -671,7 +671,7 @@ public static <E> Parser<Stream<Character>, Character, E> highSurrogate(final E
      */
     public static <E> Parser<Stream<Character>, Character, E> identifierIgnorable(final F0<E> missing,
                                                                                   final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isIdentifierIgnorable(c));
+      return StreamParser.satisfy(missing, sat, Character::isIdentifierIgnorable);
     }
 
     /**
@@ -697,7 +697,7 @@ public static <E> Parser<Stream<Character>, Character, E> identifierIgnorable(fi
      */
     public static <E> Parser<Stream<Character>, Character, E> isoControl(final F0<E> missing,
                                                                          final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isISOControl(c));
+      return StreamParser.satisfy(missing, sat, Character::isISOControl);
     }
 
     /**
@@ -722,7 +722,7 @@ public static <E> Parser<Stream<Character>, Character, E> isoControl(final E mis
      */
     public static <E> Parser<Stream<Character>, Character, E> javaIdentifierPart(final F0<E> missing,
                                                                                  final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isJavaIdentifierPart(c));
+      return StreamParser.satisfy(missing, sat, Character::isJavaIdentifierPart);
     }
 
     /**
@@ -748,7 +748,7 @@ public static <E> Parser<Stream<Character>, Character, E> javaIdentifierPart(fin
      */
     public static <E> Parser<Stream<Character>, Character, E> javaIdentifierStart(final F0<E> missing,
                                                                                   final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isJavaIdentifierStart(c));
+      return StreamParser.satisfy(missing, sat, Character::isJavaIdentifierStart);
     }
 
     /**
@@ -773,7 +773,7 @@ public static <E> Parser<Stream<Character>, Character, E> javaIdentifierStart(fi
      * @see Character#isLetter(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> alpha(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isLetter(c));
+      return StreamParser.satisfy(missing, sat, Character::isLetter);
     }
 
     /**
@@ -797,7 +797,7 @@ public static <E> Parser<Stream<Character>, Character, E> alpha(final E missing,
      * @see Character#isLetterOrDigit(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> alphaNum(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isLetterOrDigit(c));
+      return StreamParser.satisfy(missing, sat, Character::isLetterOrDigit);
     }
 
     /**
@@ -822,7 +822,7 @@ public static <E> Parser<Stream<Character>, Character, E> alphaNum(final E missi
      */
     public static <E> Parser<Stream<Character>, Character, E> lowSurrogate(final F0<E> missing,
                                                                            final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isLowSurrogate(c));
+      return StreamParser.satisfy(missing, sat, Character::isLowSurrogate);
     }
 
     /**
@@ -846,7 +846,7 @@ public static <E> Parser<Stream<Character>, Character, E> lowSurrogate(final E m
      * @see Character#isMirrored(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> mirrored(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isMirrored(c));
+      return StreamParser.satisfy(missing, sat, Character::isMirrored);
     }
 
     /**
@@ -870,7 +870,7 @@ public static <E> Parser<Stream<Character>, Character, E> mirrored(final E missi
      * @see Character#isSpace(char)
      */
     public static <E> Parser<Stream<Character>, Character, E> space(final F0<E> missing, final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isSpaceChar(c));
+      return StreamParser.satisfy(missing, sat, Character::isSpaceChar);
     }
 
     /**
@@ -895,7 +895,7 @@ public static <E> Parser<Stream<Character>, Character, E> space(final E missing,
      */
     public static <E> Parser<Stream<Character>, Character, E> titleCase(final F0<E> missing,
                                                                         final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isTitleCase(c));
+      return StreamParser.satisfy(missing, sat, Character::isTitleCase);
     }
 
     /**
@@ -920,7 +920,7 @@ public static <E> Parser<Stream<Character>, Character, E> titleCase(final E miss
      */
     public static <E> Parser<Stream<Character>, Character, E> unicodeIdentiferPart(final F0<E> missing,
                                                                                    final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isUnicodeIdentifierPart(c));
+      return StreamParser.satisfy(missing, sat, Character::isUnicodeIdentifierPart);
     }
 
     /**
@@ -946,7 +946,7 @@ public static <E> Parser<Stream<Character>, Character, E> unicodeIdentiferPart(f
      */
     public static <E> Parser<Stream<Character>, Character, E> unicodeIdentiferStart(final F0<E> missing,
                                                                                     final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isUnicodeIdentifierStart(c));
+      return StreamParser.satisfy(missing, sat, Character::isUnicodeIdentifierStart);
     }
 
     /**
@@ -972,7 +972,7 @@ public static <E> Parser<Stream<Character>, Character, E> unicodeIdentiferStart(
      */
     public static <E> Parser<Stream<Character>, Character, E> whitespace(final F0<E> missing,
                                                                          final F<Character, E> sat) {
-      return StreamParser.satisfy(missing, sat, c -> Character.isWhitespace(c));
+      return StreamParser.satisfy(missing, sat, Character::isWhitespace);
     }
 
     /**
diff --git a/core/src/main/java/fj/parser/Result.java b/core/src/main/java/fj/parser/Result.java
index f450a054..8f5a4b78 100644
--- a/core/src/main/java/fj/parser/Result.java
+++ b/core/src/main/java/fj/parser/Result.java
@@ -55,7 +55,7 @@ public <J> Result<J, A> mapRest(final F<I, J> f) {
    * @return A first-class function mapping across the remainder of the parse input.
    */
   public <J> F<F<I, J>, Result<J, A>> mapRest() {
-    return f -> mapRest(f);
+    return this::mapRest;
   }
 
   /**
@@ -74,7 +74,7 @@ public <B> Result<I, B> mapValue(final F<A, B> f) {
    * @return A first-class function mapping across the parse value.
    */
   public <B> F<F<A, B>, Result<I, B>> mapValue() {
-    return f -> mapValue(f);
+    return this::mapValue;
   }
 
   /**
@@ -94,7 +94,7 @@ public <B, J> Result<J, B> bimap(final F<I, J> f, final F<A, B> g) {
    * @return A first-class bifunctor map.
    */
   public <B, J> F<F<I, J>, F<F<A, B>, Result<J, B>>> bimap() {
-    return curry((f, g) -> bimap(f, g));
+    return curry(this::bimap);
   }
 
   /**
@@ -142,7 +142,7 @@ public static <A, I> Result<I, A> result(final I i, final A a) {
    * @return A first-class function for construction of a result.
    */
   public static <A, I> F<I, F<A, Result<I, A>>> result() {
-    return curry((i, a) -> result(i, a));
+    return curry(Result::result);
   }
 
 }
diff --git a/demo/src/main/java/fj/demo/IODemo.java b/demo/src/main/java/fj/demo/IODemo.java
index 316eafc4..0bc7db12 100644
--- a/demo/src/main/java/fj/demo/IODemo.java
+++ b/demo/src/main/java/fj/demo/IODemo.java
@@ -37,7 +37,7 @@ public void readFirstShortLine() {
      * Read a stream of input lazily using interact, in effect reading the first line
      */
     public void readFirstLine() {
-        F<LazyString, LazyString> f = lift((LazyString s) -> s.lines()).andThen(unlines_());
+        F<LazyString, LazyString> f = lift(LazyString::lines).andThen(unlines_());
         runSafe(interact(f));
     }
 
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index b4d3dae2..69b27202 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -298,7 +298,7 @@ private static P2<List<String>, Map<String, Integer>> writeSampleFiles(
   public static Map<String, Integer> getWordsAndCountsFromFilesWithIteratee(final List<String> fileNames,
       final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithIteratee) {
     final List<Map<String, Integer>> maps = fileNames.map(fileNameToWordsAndCountsWithIteratee);
-    return maps.foldLeft((Map<String, Integer> a, Map<String, Integer> b) -> plus(a, b), new HashMap<String, Integer>());
+    return maps.foldLeft(WordCount::plus, new HashMap<String, Integer>());
   }
   
   public static Map<String, Integer> getWordsAndCountsFromFilesInParallel(
diff --git a/demo/src/main/java/fj/demo/realworld/Chapter7.java b/demo/src/main/java/fj/demo/realworld/Chapter7.java
index f9263683..c239a5bf 100644
--- a/demo/src/main/java/fj/demo/realworld/Chapter7.java
+++ b/demo/src/main/java/fj/demo/realworld/Chapter7.java
@@ -28,7 +28,7 @@ public static void main(String[] args) {
     public static void toUpperLazy() {
         runSafe(interact(ls -> {
             Stream<String> stream = ls.lines().map((LazyString ls2) -> ls2.eval().toUpperCase());
-            return LazyString.unlines(stream.map(s -> LazyString.str(s)));
+            return LazyString.unlines(stream.map(LazyString::str));
         }));
     }
 
@@ -46,7 +46,7 @@ public static void toUpperByLine() {
      * uppercase line to stdout
      */
     public static void toUpperInteract() {
-        runSafe(interactWhile(s -> s.trim().length() > 0, s -> s.toUpperCase()));
+        runSafe(interactWhile(s -> s.trim().length() > 0, String::toUpperCase));
     }
 
 }
diff --git a/demo/src/main/java/fj/demo/test/EqualsHashCode.java b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
index 814f7112..c5b0a898 100644
--- a/demo/src/main/java/fj/demo/test/EqualsHashCode.java
+++ b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
@@ -62,7 +62,7 @@ public static void main(final String[] args) {
 
     // Arbitrary for MyClass that uses the restrictive arbitraries above.
     // We are using the monad pattern (bind) to make this a trivial exercise. 
-    final Arbitrary<MyClass> arbMyClass = arbitrary(arbByteR.gen.bind(arbStringR.gen, curry((b, s) -> new MyClass(b, s))));
+    final Arbitrary<MyClass> arbMyClass = arbitrary(arbByteR.gen.bind(arbStringR.gen, curry(MyClass::new)));
 
     // Finally the property.
     // if m1 equals m2, then this implies that m1's hashCode is equal to m2's hashCode.
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
index 93fd1e9e..d893a370 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/java8/src/main/java/fj/data/Java8.java
@@ -32,7 +32,7 @@ public static <A> P1<A> Supplier_P1(final Supplier<A> s) {
     }
 
     public static <A> F<Supplier<A>, P1<A>> Supplier_P1() {
-        return s -> P.lazy(() -> s.get());
+        return s -> P.lazy(s::get);
     }
 
     public static <A> Supplier<A> P1_Supplier(final P1<A> p) {
@@ -40,7 +40,7 @@ public static <A> Supplier<A> P1_Supplier(final P1<A> p) {
     }
 
     public static <A> F<P1<A>, Supplier<A>> P1_Supplier() {
-        return (p) -> () -> p._1();
+        return (p) -> p::_1;
     }
 
     public static <A, B> F<A, B> Function_F(final Function<A, B> f) {
@@ -48,7 +48,7 @@ public static <A, B> F<A, B> Function_F(final Function<A, B> f) {
     }
 
     public static <A, B> F<Function<A, B>, F<A, B>> Function_F() {
-        return f -> a -> f.apply(a);
+        return f -> f::apply;
     }
 
     public static <A, B> Function<A, B> F_Function(final F<A, B> f) {
@@ -56,7 +56,7 @@ public static <A, B> Function<A, B> F_Function(final F<A, B> f) {
     }
 
     public static <A, B> F<F<A, B>, Function<A, B>> F_Function() {
-        return f -> a -> f.f(a);
+        return f -> f::f;
     }
 
     public static <A, B, C> F2<A, B, C> BiFunction_F2(final BiFunction<A, B, C> f) {
@@ -64,7 +64,7 @@ public static <A, B, C> F2<A, B, C> BiFunction_F2(final BiFunction<A, B, C> f) {
     }
 
     public static <A, B, C> F<BiFunction<A, B, C>, F2<A, B, C>> BiFunction_F2() {
-        return f -> (a, b) -> f.apply(a, b);
+        return f -> f::apply;
     }
 
     public static <A, B, C> BiFunction<A, B, C> F2_BiFunction(final F2<A, B, C> f) {
@@ -72,7 +72,7 @@ public static <A, B, C> BiFunction<A, B, C> F2_BiFunction(final F2<A, B, C> f) {
     }
 
     public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {
-        return f -> (a, b) -> f.f(a, b);
+        return f -> f::f;
     }
 
     public static <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
@@ -120,7 +120,7 @@ public static <A> F<Option<A>, Optional<A>> Option_Optional() {
     }
 
     public static <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {
-        return c -> Consumer_F(c);
+        return Java8::Consumer_F;
     }
 
     public static <A> F<A, Unit> Consumer_F(final Consumer<A> c) {
@@ -143,7 +143,7 @@ public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<
     }
 
     public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
-        return s -> Stream_JavaStream(s);
+        return Java8::Stream_JavaStream;
     }
 
     public static <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 1e619f21..7b96d299 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -13,6 +13,8 @@
 
 import static fj.Function.compose;
 import static fj.P.p;
+
+import fj.P;
 import fj.P1;
 import fj.P2;
 import fj.P3;
@@ -32,6 +34,9 @@
 import static fj.data.List.list;
 import static fj.data.Option.some;
 
+import fj.data.List;
+import fj.data.Set;
+import fj.data.TreeMap;
 import fj.function.Effect1;
 
 import static fj.data.Stream.range;
@@ -50,29 +55,13 @@
 import java.math.BigInteger;
 import java.sql.Time;
 import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.Calendar;
-import java.util.Date;
-import java.util.EnumMap;
-import java.util.EnumSet;
-import java.util.GregorianCalendar;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Hashtable;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.Locale;
+import java.util.*;
+
 import static java.util.Locale.getAvailableLocales;
-import java.util.PriorityQueue;
-import java.util.Properties;
-import java.util.Stack;
-import java.util.TreeSet;
-import java.util.Vector;
-import java.util.WeakHashMap;
 import static java.util.EnumSet.copyOf;
+
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
@@ -127,21 +116,21 @@ public Gen<B> f(final A x) {
   }
 
     public static <A, B> Arbitrary<Reader<A, B>> arbReader(Coarbitrary<A> aa, Arbitrary<B> ab) {
-        return arbitrary(arbF(aa, ab).gen.map(f -> Reader.unit(f)));
+        return arbitrary(arbF(aa, ab).gen.map(Reader::unit));
     }
 
     /**
      * An arbitrary for state.
      */
     public static <S, A> Arbitrary<State<S, A>> arbState(Arbitrary<S> as, Coarbitrary<S> cs, Arbitrary<A> aa) {
-        return arbitrary(arbF(cs, arbP2(as, aa)).gen.map(f -> State.unit(f)));
+        return arbitrary(arbF(cs, arbP2(as, aa)).gen.map(State::unit));
     }
 
     /**
      * An arbitrary for the LcgRng.
      */
     public static <A> Arbitrary<LcgRng> arbLcgRng() {
-        return arbitrary(Arbitrary.arbLong.gen.map(l -> new LcgRng(l)));
+        return arbitrary(Arbitrary.arbLong.gen.map(LcgRng::new));
     }
 
   /**
@@ -611,11 +600,7 @@ public Gen<Float> f(final Integer i) {
    * An arbitrary implementation for string values.
    */
   public static final Arbitrary<String> arbString =
-      arbitrary(arbList(arbCharacter).gen.map(new F<List<Character>, String>() {
-        public String f(final List<Character> cs) {
-          return asString(cs);
-        }
-      }));
+      arbitrary(arbList(arbCharacter).gen.map(List::asString));
 
   /**
    * An arbitrary implementation for string values with characters in the US-ASCII range.
@@ -643,21 +628,13 @@ public Character f(final Character c) {
    * An arbitrary implementation for string buffer values.
    */
   public static final Arbitrary<StringBuffer> arbStringBuffer =
-      arbitrary(arbString.gen.map(new F<String, StringBuffer>() {
-        public StringBuffer f(final String s) {
-          return new StringBuffer(s);
-        }
-      }));
+      arbitrary(arbString.gen.map(StringBuffer::new));
 
   /**
    * An arbitrary implementation for string builder values.
    */
   public static final Arbitrary<StringBuilder> arbStringBuilder =
-      arbitrary(arbString.gen.map(new F<String, StringBuilder>() {
-        public StringBuilder f(final String s) {
-          return new StringBuilder(s);
-        }
-      }));
+      arbitrary(arbString.gen.map(StringBuilder::new));
 
   /**
    * Returns an arbitrary implementation for generators.
@@ -672,11 +649,7 @@ public Gen<Gen<A>> f(final Integer i) {
         if (i == 0)
           return fail();
         else
-          return aa.gen.map(new F<A, Gen<A>>() {
-            public Gen<A> f(final A a) {
-              return value(a);
-            }
-          }).resize(i - 1);
+          return aa.gen.map(Gen::value).resize(i - 1);
       }
     }));
   }
@@ -692,11 +665,7 @@ public static <A> Arbitrary<Option<A>> arbOption(final Arbitrary<A> aa) {
       public Gen<Option<A>> f(final Integer i) {
         return i == 0 ?
                value(Option.<A>none()) :
-               aa.gen.map(new F<A, Option<A>>() {
-                 public Option<A> f(final A a) {
-                   return some(a);
-                 }
-               }).resize(i - 1);
+               aa.gen.map(Option::some).resize(i - 1);
       }
     }));
   }
@@ -712,16 +681,8 @@ public Option<A> f(final A a) {
    */
   @SuppressWarnings("unchecked")
   public static <A, B> Arbitrary<Either<A, B>> arbEither(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-    final Gen<Either<A, B>> left = aa.gen.map(new F<A, Either<A, B>>() {
-      public Either<A, B> f(final A a) {
-        return left(a);
-      }
-    });
-    final Gen<Either<A, B>> right = ab.gen.map(new F<B, Either<A, B>>() {
-      public Either<A, B> f(final B b) {
-        return right(b);
-      }
-    });
+    final Gen<Either<A, B>> left = aa.gen.map(Either::left);
+    final Gen<Either<A, B>> right = ab.gen.map(Either::right);
     return arbitrary(oneOf(list(left, right)));
   }
 
@@ -771,7 +732,7 @@ public static <A> Arbitrary<NonEmptyList<A>> arbNonEmptyList(final Arbitrary<A>
      * Returns an arbitrary Validation for the given arbitrary parameters.
      */
     public static <A, B> Arbitrary<Validation<A, B>> arbValidation(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-        return arbitrary(arbBoolean.gen.bind(bool -> bool ? ab.gen.map(b -> Validation.<A, B>success(b)) : aa.gen.map(a -> Validation.<A, B>fail(a))));
+        return arbitrary(arbBoolean.gen.bind(bool -> bool ? ab.gen.map(Validation::<A, B>success) : aa.gen.map(Validation::<A, B>fail)));
     }
 
   /**
@@ -781,11 +742,7 @@ public static <A, B> Arbitrary<Validation<A, B>> arbValidation(final Arbitrary<A
    * @return An arbitrary implementation for streams.
    */
   public static <A> Arbitrary<Stream<A>> arbStream(final Arbitrary<A> aa) {
-    return arbitrary(arbList(aa).gen.map(new F<List<A>, Stream<A>>() {
-      public Stream<A> f(final List<A> as) {
-        return as.toStream();
-      }
-    }));
+    return arbitrary(arbList(aa).gen.map(List<A>::toStream));
   }
 
   /**
@@ -795,11 +752,7 @@ public Stream<A> f(final List<A> as) {
    * @return An arbitrary implementation for arrays.
    */
   public static <A> Arbitrary<Array<A>> arbArray(final Arbitrary<A> aa) {
-    return arbitrary(arbList(aa).gen.map(new F<List<A>, Array<A>>() {
-      public Array<A> f(final List<A> as) {
-        return as.toArray();
-      }
-    }));
+    return arbitrary(arbList(aa).gen.map(List<A>::toArray));
   }
 
   /**
@@ -830,11 +783,7 @@ public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa, in
    * @return An arbitrary implementation for throwables.
    */
   public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
-    return arbitrary(as.gen.map(new F<String, Throwable>() {
-      public Throwable f(final String msg) {
-        return new Throwable(msg);
-      }
-    }));
+    return arbitrary(as.gen.map(Throwable::new));
   }
 
   /**
@@ -888,11 +837,7 @@ public Calendar f(final Long i) {
   /**
    * An arbitrary implementation for dates.
    */
-  public static final Arbitrary<Date> arbDate = arbitrary(arbLong.gen.map(new F<Long, Date>() {
-    public Date f(final Long i) {
-      return new Date(i);
-    }
-  }));
+  public static final Arbitrary<Date> arbDate = arbitrary(arbLong.gen.map(Date::new));
 
   /**
    * Returns an arbitrary implementation for a Java enumeration.
@@ -914,12 +859,7 @@ public static <A extends Enum<A>> Arbitrary<A> arbEnumValue(final Class<A> clazz
    */
   public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final Arbitrary<K> ak,
                                                                            final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, EnumMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public EnumMap<K, V> f(final Hashtable<K, V> ht) {
-        return new EnumMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(EnumMap::new));
   }
 
   /**
@@ -957,12 +897,7 @@ public GregorianCalendar f(final Long i) {
    * @return An arbitrary implementation for hash maps.
    */
   public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, HashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public HashMap<K, V> f(final Hashtable<K, V> ht) {
-        return new HashMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(HashMap::new));
   }
 
   /**
@@ -1020,12 +955,7 @@ public void f(final P2<K, V> kv) {
    */
   public static <K, V> Arbitrary<IdentityHashMap<K, V>> arbIdentityHashMap(final Arbitrary<K> ak,
                                                                            final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, IdentityHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public IdentityHashMap<K, V> f(final Hashtable<K, V> ht) {
-        return new IdentityHashMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(IdentityHashMap::new));
   }
 
   /**
@@ -1038,12 +968,7 @@ public IdentityHashMap<K, V> f(final Hashtable<K, V> ht) {
    * @return An arbitrary implementation for linked hash maps.
    */
   public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, LinkedHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public LinkedHashMap<K, V> f(final Hashtable<K, V> ht) {
-        return new LinkedHashMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(LinkedHashMap::new));
   }
 
   /**
@@ -1130,12 +1055,7 @@ public Stack<A> f(final Array<A> a) {
    * @return An arbitrary implementation for tree maps.
    */
   public static <K, V> Arbitrary<java.util.TreeMap<K, V>> arbJavaTreeMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, java.util.TreeMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public java.util.TreeMap<K, V> f(final Hashtable<K, V> ht) {
-        return new java.util.TreeMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(java.util.TreeMap::new));
   }
 
     /**
@@ -1215,12 +1135,7 @@ public Vector<A> f(final Array<A> a) {
    * @return An arbitrary implementation for weak hash maps.
    */
   public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, WeakHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public WeakHashMap<K, V> f(final Hashtable<K, V> ht) {
-        return new WeakHashMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(WeakHashMap::new));
   }
 
   // END java.util
@@ -1263,12 +1178,7 @@ public ArrayBlockingQueue<A> f(final Boolean fair) {
    */
   public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(final Arbitrary<K> ak,
                                                                                final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(new F<Hashtable<K, V>, ConcurrentHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public ConcurrentHashMap<K, V> f(final Hashtable<K, V> ht) {
-        return new ConcurrentHashMap<K, V>(ht);
-      }
-    }));
+    return arbitrary(arbHashtable(ak, av).gen.map(ConcurrentHashMap::new));
   }
 
   /**
@@ -1388,29 +1298,17 @@ public SynchronousQueue<A> f(final Boolean fair) {
   /**
    * An arbitrary implementation for SQL dates.
    */
-  public static final Arbitrary<java.sql.Date> arbSQLDate = arbitrary(arbLong.gen.map(new F<Long, java.sql.Date>() {
-    public java.sql.Date f(final Long i) {
-      return new java.sql.Date(i);
-    }
-  }));
+  public static final Arbitrary<java.sql.Date> arbSQLDate = arbitrary(arbLong.gen.map(java.sql.Date::new));
 
   /**
    * An arbitrary implementation for SQL times.
    */
-  public static final Arbitrary<Time> arbTime = arbitrary(arbLong.gen.map(new F<Long, Time>() {
-    public Time f(final Long i) {
-      return new Time(i);
-    }
-  }));
+  public static final Arbitrary<Time> arbTime = arbitrary(arbLong.gen.map(Time::new));
 
   /**
    * An arbitrary implementation for SQL time stamps.
    */
-  public static final Arbitrary<Timestamp> arbTimestamp = arbitrary(arbLong.gen.map(new F<Long, Timestamp>() {
-    public Timestamp f(final Long i) {
-      return new Timestamp(i);
-    }
-  }));
+  public static final Arbitrary<Timestamp> arbTimestamp = arbitrary(arbLong.gen.map(Timestamp::new));
 
   // END java.sql
 
@@ -1442,11 +1340,7 @@ public BigInteger f(final Byte b) {
    * An arbitrary implementation for big decimals.
    */
   public static final Arbitrary<BigDecimal> arbBigDecimal =
-      arbitrary(arbBigInteger.gen.map(new F<BigInteger, BigDecimal>() {
-        public BigDecimal f(final BigInteger i) {
-          return new BigDecimal(i);
-        }
-      }));
+      arbitrary(arbBigInteger.gen.map(BigDecimal::new));
 
   // END java.math
 
@@ -1462,11 +1356,7 @@ public BigDecimal f(final BigInteger i) {
    * @return An arbitrary implementation for product-1 values.
    */
   public static <A> Arbitrary<P1<A>> arbP1(final Arbitrary<A> aa) {
-    return arbitrary(aa.gen.map(new F<A, P1<A>>() {
-      public P1<A> f(final A a) {
-        return p(a);
-      }
-    }));
+    return arbitrary(aa.gen.map(P::p));
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 0aa11adb..b3bb1371 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -294,11 +294,7 @@ public <B, C, D, E> Gen<E> bind(final Gen<B> gb, final Gen<C> gc, final Gen<D> g
   public <B> Gen<B> apply(final Gen<F<A, B>> gf) {
     return gf.bind(new F<F<A, B>, Gen<B>>() {
       public Gen<B> f(final F<A, B> f) {
-        return map(new F<A, B>() {
-          public B f(final A a) {
-            return f.f(a);
-          }
-        });
+        return map(f::f);
       }
     });
   }
@@ -492,11 +488,7 @@ public Gen<A> f(final Integer i) {
   public static <A> Gen<A> elemFrequency(final List<P2<Integer, A>> as) {
     return frequency(as.map(new F<P2<Integer, A>, P2<Integer, Gen<A>>>() {
       public P2<Integer, Gen<A>> f(final P2<Integer, A> p) {
-        return p.map2(new F<A, Gen<A>>() {
-          public Gen<A> f(final A a) {
-            return value(a);
-          }
-        });
+        return p.map2(Gen::value);
       }
     }));
   }
@@ -525,11 +517,7 @@ public A f(final Integer i) {
    *         requests.
    */
   public static <A> Gen<A> oneOf(final List<Gen<A>> gs) {
-    return gs.isEmpty() ? Gen.<A>fail() : choose(0, gs.length() - 1).bind(new F<Integer, Gen<A>>() {
-      public Gen<A> f(final Integer i) {
-        return gs.index(i);
-      }
-    });
+    return gs.isEmpty() ? Gen.<A>fail() : choose(0, gs.length() - 1).bind(gs::index);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 1486a695..d0eeb5ae 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -469,11 +469,7 @@ public P2<A, Result> f(final Result result) {
 
                 if (results.isEmpty())
                   return none();
-                else return results.find(new F<Option<P2<A, Result>>, Boolean>() {
-                  public Boolean f(final Option<P2<A, Result>> o) {
-                    return failed(o);
-                  }
-                }).orSome(() -> results.head());
+                else return results.find(this::failed).orSome(results::head);
               }
 
               public boolean failed(final Option<P2<A, Result>> o) {
diff --git a/quickcheck/src/main/java/fj/test/Result.java b/quickcheck/src/main/java/fj/test/Result.java
index 40130542..467e2ae2 100644
--- a/quickcheck/src/main/java/fj/test/Result.java
+++ b/quickcheck/src/main/java/fj/test/Result.java
@@ -156,7 +156,7 @@ public Option<Result> toOption() {
    * @return The result that may be {@link #noResult() noResult()}.
    */
   public static Result noResult(final Option<Result> r) {
-    return r.orSome(() -> noResult());
+    return r.orSome(Result::noResult);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index a9d1aa21..751a1307 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -235,7 +235,7 @@ else if (as.tail().isEmpty())
                                                            .map(aas1 -> aas1.append(as2))
                                                            .interleave(removeChunks(n2, as2)
                                                                    .filter(isNotEmpty)
-                                                                   .map(aas -> as1.append(aas)))));
+                                                                   .map(as1::append))));
                   })
           );
         }
@@ -301,7 +301,7 @@ public static <A> Shrink<Stream<A>> shrinkStream(final Shrink<A> sa) {
    * @return A shrink strategy for throwables.
    */
   public static Shrink<Throwable> shrinkThrowable(final Shrink<String> ss) {
-    return ss.map(s -> new Throwable(s), t -> t.getMessage());
+    return ss.map(Throwable::new, Throwable::getMessage);
   }
 
   /**
@@ -341,7 +341,7 @@ public static <A> Shrink<ArrayList<A>> shrinkArrayList(final Shrink<A> sa) {
    * A shrink strategy for dates.
    */
   public static final Shrink<Date> shrinkDate =
-      shrinkLong.map(i -> new Date(i), d -> d.getTime());
+      shrinkLong.map(Date::new, Date::getTime);
 
   /**
    * A shrink strategy for enum maps.
@@ -351,7 +351,7 @@ public static <A> Shrink<ArrayList<A>> shrinkArrayList(final Shrink<A> sa) {
    * @return A shrink strategy for enum maps.
    */
   public static <K extends Enum<K>, V> Shrink<EnumMap<K, V>> shrinkEnumMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new EnumMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(EnumMap::new, Hashtable::new);
   }
 
   /**
@@ -382,7 +382,7 @@ public static <A extends Enum<A>> Shrink<EnumSet<A>> shrinkEnumSet(final Shrink<
    * @return A shrink strategy for hash maps.
    */
   public static <K, V> Shrink<HashMap<K, V>> shrinkHashMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new HashMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(HashMap::new, Hashtable::new);
   }
 
   /**
@@ -427,7 +427,7 @@ public static <K, V> Shrink<Hashtable<K, V>> shrinkHashtable(final Shrink<K> sk,
    * @return A shrink strategy for identity hash maps.
    */
   public static <K, V> Shrink<IdentityHashMap<K, V>> shrinkIdentityHashMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new IdentityHashMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(IdentityHashMap::new, Hashtable::new);
   }
 
   /**
@@ -438,7 +438,7 @@ public static <K, V> Shrink<IdentityHashMap<K, V>> shrinkIdentityHashMap(final S
    * @return A shrink strategy for linked hash maps.
    */
   public static <K, V> Shrink<LinkedHashMap<K, V>> shrinkLinkedHashMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new LinkedHashMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(LinkedHashMap::new, Hashtable::new);
   }
 
   /**
@@ -511,7 +511,7 @@ public static <A> Shrink<Stack<A>> shrinkStack(final Shrink<A> sa) {
    * @return A shrink strategy for tree maps.
    */
   public static <K, V> Shrink<TreeMap<K, V>> shrinkTreeMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new TreeMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(TreeMap::new, Hashtable::new);
   }
 
   /**
@@ -542,7 +542,7 @@ public static <A> Shrink<Vector<A>> shrinkVector(final Shrink<A> sa) {
    * @return A shrink strategy for weak hash maps.
    */
   public static <K, V> Shrink<WeakHashMap<K, V>> shrinkWeakHashMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new WeakHashMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(WeakHashMap::new, Hashtable::new);
   }
 
   // END java.util
@@ -567,7 +567,7 @@ public static <A> Shrink<ArrayBlockingQueue<A>> shrinkArrayBlockingQueue(final S
    * @return A shrink strategy for concurrent hash maps.
    */
   public static <K, V> Shrink<ConcurrentHashMap<K, V>> shrinkConcurrentHashMap(final Shrink<K> sk, final Shrink<V> sv) {
-    return shrinkHashtable(sk, sv).map(h -> new ConcurrentHashMap<K, V>(h), m -> new Hashtable<K, V>(m));
+    return shrinkHashtable(sk, sv).map(ConcurrentHashMap::new, Hashtable::new);
   }
 
   /**
@@ -648,19 +648,19 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
    * A shrink strategy for SQL dates.
    */
   public static final Shrink<java.sql.Date> shrinkSQLDate =
-      shrinkLong.map(i -> new java.sql.Date(i), c -> c.getTime());
+      shrinkLong.map(java.sql.Date::new, Date::getTime);
 
   /**
    * A shrink strategy for SQL times.
    */
   public static final Shrink<Time> shrinkTime =
-      shrinkLong.map(i -> new Time(i), c -> c.getTime());
+      shrinkLong.map(Time::new, Date::getTime);
 
   /**
    * A shrink strategy for SQL timestamps.
    */
   public static final Shrink<Timestamp> shrinkTimestamp =
-      shrinkLong.map(i -> new Timestamp(i), c -> c.getTime());
+      shrinkLong.map(Timestamp::new, Timestamp::getTime);
 
   // END java.sql
 
@@ -691,7 +691,7 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
    * A shrink strategy for big decimals.
    */
   public static final Shrink<BigDecimal> shrinkBigDecimal =
-      shrinkBigInteger.map(i -> new BigDecimal(i), d -> d.toBigInteger());
+      shrinkBigInteger.map(BigDecimal::new, BigDecimal::toBigInteger);
 
   // END java.math
 
@@ -702,7 +702,7 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
    * @return a shrinking strategy for product-1 values.
    */
   public static <A> Shrink<P1<A>> shrinkP1(final Shrink<A> sa) {
-    return shrink(p -> sa.shrink(p._1()).map(a -> p(a)));
+    return shrink(p -> sa.shrink(p._1()).map(P::p));
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index 5b7dbbb3..a4994bcb 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -300,11 +300,7 @@ public Boolean f(final String cs) {
       }
     };
 
-    final F<Name, String> nameS = new F<Name, String>() {
-      public String f(final Name name) {
-        return name.value();
-      }
-    };
+    final F<Name, String> nameS = Name::value;
 
     return ms.filter(new F<PropertyMember, Boolean>() {
       public Boolean f(final PropertyMember m) {

From a93c54c2d274b731c57b3fce6791e9e996b6b9ac Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 22:39:50 +0100
Subject: [PATCH 044/336] Use lambda syntax instead of anonymous class whenever
 possible

---
 core/src/main/java/fj/control/Trampoline.java |  18 +-
 .../java/fj/control/parallel/Callables.java   |  28 +-
 .../java/fj/control/parallel/Strategy.java    |   4 +-
 core/src/main/java/fj/data/IOFunctions.java   | 245 +++---
 core/src/main/java/fj/data/Iteratee.java      |  11 +-
 core/src/main/java/fj/data/Java.java          |  12 +-
 core/src/main/java/fj/data/NonEmptyList.java  |  10 +-
 core/src/main/java/fj/data/TreeZipper.java    |  19 +-
 .../main/java/fj/data/fingertrees/Deep.java   | 712 +++++-------------
 demo/src/main/java/fj/demo/ChequeWrite.java   |  24 +-
 demo/src/main/java/fj/demo/List_groupBy.java  |  12 +-
 .../java/fj/demo/concurrent/PingPong.java     |  16 +-
 .../java/fj/demo/concurrent/WordCount.java    |  70 +-
 .../src/main/java/fj/demo/euler/Problem2.java |   5 +-
 .../java/fj/demo/test/ListFunctorLaws.java    |   8 +-
 demo/src/main/java/fj/demo/test/Reflect.java  |   8 +-
 .../fj/demo/test/StringBuilderReverse.java    |   6 +-
 .../src/main/java/fj/test/Arbitrary.java      | 454 ++---------
 .../src/main/java/fj/test/Coarbitrary.java    |  12 +-
 quickcheck/src/main/java/fj/test/Gen.java     |  98 +--
 .../src/main/java/fj/test/Property.java       | 488 ++----------
 .../src/main/java/fj/test/reflect/Check.java  | 211 +++---
 .../src/main/java/fj/test/reflect/Main.java   |   8 +-
 23 files changed, 640 insertions(+), 1839 deletions(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 140deeaa..a41c7a03 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -52,16 +52,14 @@ public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
     // gets shifted into the continuation.
     public Either<P1<Trampoline<A>>, A> resume() {
-      return left(sub.resume().either(p -> {
-        return p.map(ot -> {
-          // WARNING: In JDK 8, update 25 (current version) the following code is a
-          // workaround for an internal JDK compiler error, likely due to
-          // https:bugs.openjdk.java.net/browse/JDK-8062253.
-          F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
-          F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
-          return ot.fold(f, g);
-        });
-      }, o -> P.lazy(() -> cont.f(o))));
+      return left(sub.resume().either(p -> p.map(ot -> {
+        // WARNING: In JDK 8, update 25 (current version) the following code is a
+        // workaround for an internal JDK compiler error, likely due to
+        // https:bugs.openjdk.java.net/browse/JDK-8062253.
+        F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
+        F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
+        return ot.fold(f, g);
+      }), o -> P.lazy(() -> cont.f(o))));
     }
   }
 
diff --git a/core/src/main/java/fj/control/parallel/Callables.java b/core/src/main/java/fj/control/parallel/Callables.java
index 40c8e746..7c2a7221 100644
--- a/core/src/main/java/fj/control/parallel/Callables.java
+++ b/core/src/main/java/fj/control/parallel/Callables.java
@@ -216,14 +216,12 @@ public static <A> F<Callable<A>, P1<Either<Exception, A>>> either() {
    * @return A Callable equivalent to the given Either value.
    */
   public static <A> Callable<A> fromEither(final F0<Either<Exception, A>> e) {
-    return new Callable<A>() {
-      public A call() throws Exception {
-        final Either<Exception, A> e1 = e.f();
-        if (e1.isLeft())
-          throw e1.left().value();
-        else
-          return e1.right().value();
-      }
+    return () -> {
+      final Either<Exception, A> e1 = e.f();
+      if (e1.isLeft())
+        throw e1.left().value();
+      else
+        return e1.right().value();
     };
   }
 
@@ -243,14 +241,12 @@ public static <A> F<P1<Either<Exception, A>>, Callable<A>> fromEither() {
    * @return A Callable that yields some value or throws an exception in the case of no value.
    */
   public static <A> Callable<A> fromOption(final F0<Option<A>> o) {
-    return new Callable<A>() {
-      public A call() throws Exception {
-        final Option<A> o1 = o.f();
-        if (o1.isSome())
-          return o1.some();
-        else
-          throw new Exception("No value.");
-      }
+    return () -> {
+      final Option<A> o1 = o.f();
+      if (o1.isSome())
+        return o1.some();
+      else
+        throw new Exception("No value.");
     };
   }
 
diff --git a/core/src/main/java/fj/control/parallel/Strategy.java b/core/src/main/java/fj/control/parallel/Strategy.java
index 79e698b9..94e1f148 100644
--- a/core/src/main/java/fj/control/parallel/Strategy.java
+++ b/core/src/main/java/fj/control/parallel/Strategy.java
@@ -339,9 +339,7 @@ public static <A> P1<A> obtain(final Future<A> t) {
    * @return An effect, which, given a Future, waits for it to obtain a value, discarding the value.
    */
   public static <A> Effect1<Future<A>> discard() {
-    return a -> {
-      Strategy.<A>obtain().f(a)._1();
-    };
+    return a -> Strategy.<A>obtain().f(a)._1();
   }
 
   /**
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index b62bb60e..c3d5fe01 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -76,12 +76,9 @@ public static <A> A runSafe(IO<A> io) {
     }
 
     public static IO<Unit> closeReader(final Reader r) {
-        return new IO<Unit>() {
-            @Override
-            public Unit run() throws IOException {
-                r.close();
-                return Unit.unit();
-            }
+        return () -> {
+            r.close();
+            return Unit.unit();
         };
     }
 
@@ -139,24 +136,16 @@ public static IO<Reader> fileReader(final File f, final Option<Charset> encoding
     }
 
     public static <A, B, C> IO<C> bracket(final IO<A> init, final F<A, IO<B>> fin, final F<A, IO<C>> body) {
-        return new IO<C>() {
-            @Override
-            public C run() throws IOException {
-                final A a = init.run();
-                try(Closeable finAsCloseable = fin.f(a)::run) {
-                    return body.f(a).run();
-                }
+        return () -> {
+            final A a = init.run();
+            try(Closeable finAsCloseable = fin.f(a)::run) {
+                return body.f(a).run();
             }
         };
     }
 
     public static <A> IO<A> unit(final A a) {
-        return new IO<A>() {
-            @Override
-            public A run() throws IOException {
-                return a;
-            }
-        };
+        return () -> a;
     }
 
     public static final IO<Unit> ioUnit = unit(Unit.unit());
@@ -192,32 +181,24 @@ public Boolean f(final IterV<String, A> i) {
                     }
                 };
 
-        return new F<BufferedReader, F<IterV<String, A>, IO<IterV<String, A>>>>() {
-            @Override
-            public F<IterV<String, A>, IO<IterV<String, A>>> f(final BufferedReader r) {
-                return new F<IterV<String, A>, IO<IterV<String, A>>>() {
-                    final F<P2<A, Input<String>>, P1<IterV<String, A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
+        return r -> new F<IterV<String, A>, IO<IterV<String, A>>>() {
+            final F<P2<A, Input<String>>, P1<IterV<String, A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
 
-                    @Override
-                    public IO<IterV<String, A>> f(final IterV<String, A> it) {
-                        // use loop instead of recursion because of missing TCO
-                        return new IO<Iteratee.IterV<String, A>>() {
-                            @Override
-                            public IterV<String, A> run() throws IOException {
-                                IterV<String, A> i = it;
-                                while (!isDone.f(i)) {
-                                    final String s = r.readLine();
-                                    if (s == null) {
-                                        return i;
-                                    }
-                                    final Input<String> input = Input.<String>el(s);
-                                    final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.<Input<String>, IterV<String, A>>apply(input));
-                                    i = i.fold(done, cont)._1();
-                                }
-                                return i;
-                            }
-                        };
+            @Override
+            public IO<IterV<String, A>> f(final IterV<String, A> it) {
+                // use loop instead of recursion because of missing TCO
+                return () -> {
+                    IterV<String, A> i = it;
+                    while (!isDone.f(i)) {
+                        final String s = r.readLine();
+                        if (s == null) {
+                            return i;
+                        }
+                        final Input<String> input = Input.<String>el(s);
+                        final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.<Input<String>, IterV<String, A>>apply(input));
+                        i = i.fold(done, cont)._1();
                     }
+                    return i;
                 };
             }
         };
@@ -239,38 +220,30 @@ public Boolean f(final IterV<char[], A> i) {
                     }
                 };
 
-        return new F<Reader, F<IterV<char[], A>, IO<IterV<char[], A>>>>() {
-            @Override
-            public F<IterV<char[], A>, IO<IterV<char[], A>>> f(final Reader r) {
-                return new F<IterV<char[], A>, IO<IterV<char[], A>>>() {
-                    final F<P2<A, Input<char[]>>, P1<IterV<char[], A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
+        return r -> new F<IterV<char[], A>, IO<IterV<char[], A>>>() {
+            final F<P2<A, Input<char[]>>, P1<IterV<char[], A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
 
-                    @Override
-                    public IO<IterV<char[], A>> f(final IterV<char[], A> it) {
-                        // use loop instead of recursion because of missing TCO
-                        return new IO<Iteratee.IterV<char[], A>>() {
-                            @Override
-                            public IterV<char[], A> run() throws IOException {
-
-                                IterV<char[], A> i = it;
-                                while (!isDone.f(i)) {
-                                    char[] buffer = new char[DEFAULT_BUFFER_SIZE];
-                                    final int numRead = r.read(buffer);
-                                    if (numRead == -1) {
-                                        return i;
-                                    }
-                                    if (numRead < buffer.length) {
-                                        buffer = Arrays.copyOfRange(buffer, 0, numRead);
-                                    }
-                                    final Input<char[]> input = Input.<char[]>el(buffer);
-                                    final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
-                                            F1Functions.lazy(Function.<Input<char[]>, IterV<char[], A>>apply(input));
-                                    i = i.fold(done, cont)._1();
-                                }
-                                return i;
-                            }
-                        };
+            @Override
+            public IO<IterV<char[], A>> f(final IterV<char[], A> it) {
+                // use loop instead of recursion because of missing TCO
+                return () -> {
+
+                    IterV<char[], A> i = it;
+                    while (!isDone.f(i)) {
+                        char[] buffer = new char[DEFAULT_BUFFER_SIZE];
+                        final int numRead = r.read(buffer);
+                        if (numRead == -1) {
+                            return i;
+                        }
+                        if (numRead < buffer.length) {
+                            buffer = Arrays.copyOfRange(buffer, 0, numRead);
+                        }
+                        final Input<char[]> input = Input.<char[]>el(buffer);
+                        final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
+                                F1Functions.lazy(Function.<Input<char[]>, IterV<char[], A>>apply(input));
+                        i = i.fold(done, cont)._1();
                     }
+                    return i;
                 };
             }
         };
@@ -292,52 +265,39 @@ public Boolean f(final IterV<Character, A> i) {
                     }
                 };
 
-        return new F<Reader, F<IterV<Character, A>, IO<IterV<Character, A>>>>() {
-            @Override
-            public F<IterV<Character, A>, IO<IterV<Character, A>>> f(final Reader r) {
-                return new F<IterV<Character, A>, IO<IterV<Character, A>>>() {
-                    final F<P2<A, Input<Character>>, IterV<Character, A>> done = errorF("iteratee is done"); //$NON-NLS-1$
+        return r -> new F<IterV<Character, A>, IO<IterV<Character, A>>>() {
+            final F<P2<A, Input<Character>>, IterV<Character, A>> done = errorF("iteratee is done"); //$NON-NLS-1$
 
-                    @Override
-                    public IO<IterV<Character, A>> f(final IterV<Character, A> it) {
-                        // use loop instead of recursion because of missing TCO
-                        return new IO<Iteratee.IterV<Character, A>>() {
-                            @Override
-                            public IterV<Character, A> run() throws IOException {
-
-                                IterV<Character, A> i = it;
-                                while (!isDone.f(i)) {
-                                    char[] buffer = new char[DEFAULT_BUFFER_SIZE];
-                                    final int numRead = r.read(buffer);
-                                    if (numRead == -1) {
-                                        return i;
-                                    }
-                                    if (numRead < buffer.length) {
-                                        buffer = Arrays.copyOfRange(buffer, 0, numRead);
-                                    }
-                                    for (int c = 0; c < buffer.length; c++) {
-                                        final Input<Character> input = Input.el(buffer[c]);
-                                        final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
-                                                Function.<Input<Character>, IterV<Character, A>>apply(input);
-                                        i = i.fold(done, cont);
-                                    }
-                                }
-                                return i;
-                            }
-                        };
+            @Override
+            public IO<IterV<Character, A>> f(final IterV<Character, A> it) {
+                // use loop instead of recursion because of missing TCO
+                return () -> {
+
+                    IterV<Character, A> i = it;
+                    while (!isDone.f(i)) {
+                        char[] buffer = new char[DEFAULT_BUFFER_SIZE];
+                        final int numRead = r.read(buffer);
+                        if (numRead == -1) {
+                            return i;
+                        }
+                        if (numRead < buffer.length) {
+                            buffer = Arrays.copyOfRange(buffer, 0, numRead);
+                        }
+                        for (int c = 0; c < buffer.length; c++) {
+                            final Input<Character> input = Input.el(buffer[c]);
+                            final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
+                                    Function.<Input<Character>, IterV<Character, A>>apply(input);
+                            i = i.fold(done, cont);
+                        }
                     }
+                    return i;
                 };
             }
         };
     }
 
     public static <A, B> IO<B> map(final IO<A> io, final F<A, B> f) {
-        return new IO<B>() {
-            @Override
-            public B run() throws IOException {
-                return f.f(io.run());
-            }
-        };
+        return () -> f.f(io.run());
     }
 
     public static <A, B> IO<B> as(final IO<A> io, final B b) {
@@ -349,12 +309,7 @@ public static <A> IO<Unit> voided(final IO <A> io) {
     }
 
     public static <A, B> IO<B> bind(final IO<A> io, final F<A, IO<B>> f) {
-        return new IO<B>() {
-            @Override
-            public B run() throws IOException {
-                return f.f(io.run()).run();
-            }
-        };
+        return () -> f.f(io.run()).run();
     }
 
     public static IO<Unit> when(final Boolean b, final IO<Unit> io) {
@@ -422,46 +377,40 @@ public static IO<Unit> interactWhile(F<String, Boolean> condition, F<String, Str
     }
 
     public static <A> IO<Stream<A>> sequenceWhileEager(final Stream<IO<A>> stream, final F<A, Boolean> f) {
-        return new IO<Stream<A>>() {
-            @Override
-            public Stream<A> run() throws IOException {
-                boolean loop = true;
-                Stream<IO<A>> input = stream;
-                Stream<A> result = Stream.<A>nil();
-                while (loop) {
-                    if (input.isEmpty()) {
+        return () -> {
+            boolean loop = true;
+            Stream<IO<A>> input = stream;
+            Stream<A> result = Stream.<A>nil();
+            while (loop) {
+                if (input.isEmpty()) {
+                    loop = false;
+                } else {
+                    A a = input.head().run();
+                    if (!f.f(a)) {
                         loop = false;
                     } else {
-                        A a = input.head().run();
-                        if (!f.f(a)) {
-                            loop = false;
-                        } else {
-                            input = input.tail()._1();
-                            result = result.cons(a);
-                        }
+                        input = input.tail()._1();
+                        result = result.cons(a);
                     }
                 }
-                return result.reverse();
             }
+            return result.reverse();
         };
     }
 
     public static <A> IO<Stream<A>> sequenceWhile(final Stream<IO<A>> stream, final F<A, Boolean> f) {
-        return new IO<Stream<A>>() {
-            @Override
-            public Stream<A> run() throws IOException {
-                if (stream.isEmpty()) {
+        return () -> {
+            if (stream.isEmpty()) {
+                return Stream.nil();
+            } else {
+                IO<A> io = stream.head();
+                A a = io.run();
+                if (!f.f(a)) {
                     return Stream.nil();
                 } else {
-                    IO<A> io = stream.head();
-                    A a = io.run();
-                    if (!f.f(a)) {
-                        return Stream.nil();
-                    } else {
-                        IO<Stream<A>> io2 = sequenceWhile(stream.tail()._1(), f);
-                        SafeIO<Stream<A>> s3 = toSafe(io2::run);
-                        return Stream.cons(a, s3::run);
-                    }
+                    IO<Stream<A>> io2 = sequenceWhile(stream.tail()._1(), f);
+                    SafeIO<Stream<A>> s3 = toSafe(io2::run);
+                    return Stream.cons(a, s3::run);
                 }
             }
         };
@@ -505,9 +454,7 @@ public static IO<Unit> stdoutPrint(final String s) {
 
     public static IO<LazyString> getContents() {
         Stream<IO<Integer>> s = Stream.<IO<Integer>>repeat(() -> (int) stdinBufferedReader.read());
-        return map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> {
-            return (char) i.intValue();
-        })));
+        return map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> (char) i.intValue())));
     }
 
     public static IO<Unit> interact(F<LazyString, LazyString> f) {
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index 5912ec1b..391c4087 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -99,11 +99,9 @@ public Option<A> f(final IterV<E, A> i) {
     /** TODO more documentation */
     public final <B> IterV<E, B> bind(final F<A, IterV<E, B>> f) {
       final F<P2<A, Input<E>>, IterV<E, B>> done =
-        new F<P2<A, Input<E>>, IterV<E, B>>() {
-          @Override
-          public IterV<E, B> f(final P2<A, Input<E>> xe) {
+          xe -> {
             final Input<E> e = xe._2();
-            final F<P2<B, Input<E>>, IterV<E, B>> done =
+            final F<P2<B, Input<E>>, IterV<E, B>> done1 =
                     y_ -> {
                       final B y = y_._1();
                       return done(y, e);
@@ -111,9 +109,8 @@ public IterV<E, B> f(final P2<A, Input<E>> xe) {
             final F<F<Input<E>, IterV<E, B>>, IterV<E, B>> cont =
                     k -> k.f(e);
             final A x = xe._1();
-            return f.f(x).fold(done, cont);
-          }
-        };
+            return f.f(x).fold(done1, cont);
+          };
       final F<F<Input<E>, IterV<E, A>>, IterV<E, B>> cont =
               k -> cont(e -> k.f(e).bind(f));
       return this.fold(done, cont);
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 8836fe2f..0be648f2 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -59,9 +59,7 @@ public static <A> F<List<A>, ArrayList<A>> List_ArrayList() {
    */
   public static final F<List<Boolean>, BitSet> List_BitSet = bs -> {
     final BitSet s = new BitSet(bs.length());
-    bs.zipIndex().foreachDoEffect(bi -> {
-        s.set(bi._2(), bi._1());
-    });
+    bs.zipIndex().foreachDoEffect(bi -> s.set(bi._2(), bi._1()));
     return s;
   };
 
@@ -238,9 +236,7 @@ public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
   public static final F<Array<Boolean>, BitSet> Array_BitSet = bs -> {
     final BitSet s = new BitSet(bs.length());
 
-    bs.zipIndex().foreachDoEffect(bi -> {
-      s.set(bi._2(), bi._1());
-    });
+    bs.zipIndex().foreachDoEffect(bi -> s.set(bi._2(), bi._1()));
     return s;
   };
 
@@ -445,9 +441,7 @@ public static <A> F<Stream<A>, ArrayList<A>> Stream_ArrayList() {
    */
   public static final F<Stream<Boolean>, BitSet> Stream_BitSet = bs -> {
     final BitSet s = new BitSet(bs.length());
-    bs.zipIndex().foreachDoEffect(bi -> {
-      s.set(bi._2(), bi._1());
-    });
+    bs.zipIndex().foreachDoEffect(bi -> s.set(bi._2(), bi._1()));
     return s;
   };
 
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index 611bef93..c8dd4cca 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -108,12 +108,10 @@ public <B> NonEmptyList<B> bind(final F<A, NonEmptyList<B>> f) {
     final NonEmptyList<B> p = f.f(head);
     b.snoc(p.head);
     b.append(p.tail);
-    tail.foreachDoEffect(new Effect1<A>() {
-        public void f(final A a) {
-            final NonEmptyList<B> p = f.f(a);
-            b.snoc(p.head);
-            b.append(p.tail);
-        }
+    tail.foreachDoEffect(a -> {
+        final NonEmptyList<B> p1 = f.f(a);
+        b.snoc(p1.head);
+        b.append(p1.tail);
     });
     final List<B> bb = b.toList();
     return nel(bb.head(), bb.tail());
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index 3cfeff7c..a9d92b5a 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -585,21 +585,14 @@ public TreeZipper<TreeZipper<A>> positions() {
     final Stream<Tree<TreeZipper<A>>> l = uf(TreeZipper.<A>left_());
     final Stream<Tree<TreeZipper<A>>> r = uf(TreeZipper.<A>right_());
     final Stream<P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>> p = unfold(
-        new F<Option<TreeZipper<A>>,
-            Option<P2<
-                P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
-                Option<TreeZipper<A>>>>>() {
-          public Option<P2<
+        o -> {
+          Option<P2<
               P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
-              Option<TreeZipper<A>>>> f(final Option<TreeZipper<A>> o) {
-            Option<P2<
-                P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
-                Option<TreeZipper<A>>>> r = none();
-            for (final TreeZipper<A> z : o) {
-              r = some(P.p(P.p(z.uf(TreeZipper.<A>left_()), z, z.uf(TreeZipper.<A>right_())), z.parent()));
-            }
-            return r;
+              Option<TreeZipper<A>>>> r1 = none();
+          for (final TreeZipper<A> z : o) {
+            r1 = some(P.p(P.p(z.uf(TreeZipper.<A>left_()), z, z.uf(TreeZipper.<A>right_())), z.parent()));
           }
+          return r1;
         }, parent());
     return treeZipper(t, l, r, p);
   }
diff --git a/core/src/main/java/fj/data/fingertrees/Deep.java b/core/src/main/java/fj/data/fingertrees/Deep.java
index a33637d8..17e775e6 100644
--- a/core/src/main/java/fj/data/fingertrees/Deep.java
+++ b/core/src/main/java/fj/data/fingertrees/Deep.java
@@ -208,23 +208,21 @@ private static <V, A> FingerTree<V, Node<V, A>> addDigits0(
 
         final MakeTree<V, A> mk = mkTree(m);
         return s1.match(
-            one1 -> {
-                return p2.match(
-                    one2 -> append1(m, m1, mk.node2(one1.value(), one2.value()), m2),
-                    two2 -> {
-                        final V2<A> vs = two2.values();
-                        return append1(m, m1, mk.node3(one1.value(), vs._1(), vs._2()), m2);
-                    },
-                    three -> {
-                        final V3<A> vs = three.values();
-                        return append2(m, m1, mk.node2(one1.value(), vs._1()), mk.node2(vs._2(), vs._3()), m2);
-                    },
-                    four -> {
-                        final V4<A> vs = four.values();
-                        return append2(m, m1, mk.node3(one1.value(), vs._1(), vs._2()), mk.node2(vs._3(), vs._4()), m2);
-                    }
-                );
-            },
+            one1 -> p2.match(
+                one2 -> append1(m, m1, mk.node2(one1.value(), one2.value()), m2),
+                two2 -> {
+                    final V2<A> vs = two2.values();
+                    return append1(m, m1, mk.node3(one1.value(), vs._1(), vs._2()), m2);
+                },
+                three -> {
+                    final V3<A> vs = three.values();
+                    return append2(m, m1, mk.node2(one1.value(), vs._1()), mk.node2(vs._2(), vs._3()), m2);
+                },
+                four -> {
+                    final V4<A> vs = four.values();
+                    return append2(m, m1, mk.node3(one1.value(), vs._1(), vs._2()), mk.node2(vs._3(), vs._4()), m2);
+                }
+            ),
             two1 -> {
                 final V2<A> v1 = two1.values();
                 return p2.match(
@@ -281,34 +279,12 @@ private static <V, A> FingerTree<V, Node<V, A>> addDigits0(
 
   private static <V, A> FingerTree<V, Node<V, A>> append1(final Measured<V, A> m, final FingerTree<V, Node<V, A>> xs,
                                                           final Node<V, A> a, final FingerTree<V, Node<V, A>> ys) {
-    return xs.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-        return ys.cons(a);
-      }
-    }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-        return ys.cons(a).cons(single.value());
-      }
-    }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep1) {
-        return ys.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-            return xs.snoc(a);
-          }
-        }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-            return xs.snoc(a).snoc(single.value());
-          }
-        }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep2) {
-            final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-            return new Deep<V, Node<V, A>>(nm, m.sum(m.sum(deep1.v, nm.measure(a)), deep2.v), deep1.prefix,
-                                           addDigits1(nm, deep1.middle, deep1.suffix, a, deep2.prefix, deep2.middle),
-                                           deep2.suffix);
-          }
-        });
-      }
-    });
+    return xs.match(empty -> ys.cons(a), single -> ys.cons(a).cons(single.value()), deep1 -> ys.match(empty -> xs.snoc(a), single -> xs.snoc(a).snoc(single.value()), deep2 -> {
+      final Measured<V, Node<V, A>> nm = m.nodeMeasured();
+      return new Deep<V, Node<V, A>>(nm, m.sum(m.sum(deep1.v, nm.measure(a)), deep2.v), deep1.prefix,
+                                     addDigits1(nm, deep1.middle, deep1.suffix, a, deep2.prefix, deep2.middle),
+                                     deep2.suffix);
+    }));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits1(final Measured<V, Node<V, A>> m,
@@ -317,136 +293,54 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits1(final Measur
                                                                       final Digit<V, Node<V, A>> y,
                                                                       final FingerTree<V, Node<V, Node<V, A>>> m2) {
     final MakeTree<V, Node<V, A>> mk = mkTree(m);
-    return x.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one1) {
-        return y.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one2) {
-            return append1(m, m1, mk.node3(one1.value(), n, one2.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append2(m, m1, mk.node2(one1.value(), n), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append2(m, m1, mk.node3(one1.value(), n, v2._1()), mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append2(m, m1, mk.node3(one1.value(), n, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two1) {
-        final V2<Node<V, A>> v1 = two1.values();
-        return y.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node2(v1), mk.node2(n, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node3(three.values()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()),
-                           m2);
-          }
-        });
-      }
-    }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-        final V3<Node<V, A>> v1 = three.values();
-        return y.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node3(v1), mk.node2(n, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            final V2<Node<V, A>> v2 = two.values();
-            return append2(m, m1, mk.node3(v1), mk.node3(n, v2._1(), v2._2()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(v1), mk.node2(n, v2._1()), mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1), mk.node3(n, v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-        final V4<Node<V, A>> v1 = four.values();
-        return y.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node2(v1._4(), n), mk.node2(two.values()),
-                           m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, v2._1()),
-                           mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, v2._1()),
-                           mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
+    return x.match(one1 -> y.match(one2 -> append1(m, m1, mk.node3(one1.value(), n, one2.value()), m2), two -> append2(m, m1, mk.node2(one1.value(), n), mk.node2(two.values()), m2), three -> {
+      final V3<Node<V, A>> v2 = three.values();
+      return append2(m, m1, mk.node3(one1.value(), n, v2._1()), mk.node2(v2._2(), v2._3()), m2);
+    }, four -> {
+      final V4<Node<V, A>> v2 = four.values();
+      return append2(m, m1, mk.node3(one1.value(), n, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
+    }), two1 -> {
+      final V2<Node<V, A>> v1 = two1.values();
+      return y.match(one -> append2(m, m1, mk.node2(v1), mk.node2(n, one.value()), m2), two -> append2(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node2(two.values()), m2), three -> append2(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node3(three.values()), m2), four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), n), mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()),
+                       m2);
+      });
+    }, three -> {
+      final V3<Node<V, A>> v1 = three.values();
+      return y.match(one -> append2(m, m1, mk.node3(v1), mk.node2(n, one.value()), m2), two -> {
+        final V2<Node<V, A>> v2 = two.values();
+        return append2(m, m1, mk.node3(v1), mk.node3(n, v2._1(), v2._2()), m2);
+      }, three1 -> {
+        final V3<Node<V, A>> v2 = three1.values();
+        return append3(m, m1, mk.node3(v1), mk.node2(n, v2._1()), mk.node2(v2._2(), v2._3()), m2);
+      }, four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append3(m, m1, mk.node3(v1), mk.node3(n, v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
+      });
+    }, four -> {
+      final V4<Node<V, A>> v1 = four.values();
+      return y.match(one -> append2(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, one.value()), m2), two -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node2(v1._4(), n), mk.node2(two.values()),
+                     m2), three -> {
+        final V3<Node<V, A>> v2 = three.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, v2._1()),
+                       mk.node2(v2._2(), v2._3()), m2);
+      }, four1 -> {
+        final V4<Node<V, A>> v2 = four1.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n, v2._1()),
+                       mk.node3(v2._2(), v2._3(), v2._4()), m2);
+      });
     });
   }
 
   private static <V, A> FingerTree<V, Node<V, A>> append2(final Measured<V, A> m, final FingerTree<V, Node<V, A>> t1,
                                                           final Node<V, A> n1, final Node<V, A> n2,
                                                           final FingerTree<V, Node<V, A>> t2) {
-    return t1.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-        return t2.cons(n2).cons(n1);
-      }
-    }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-        return t2.cons(n2).cons(n1).cons(single.value());
-      }
-    }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep) {
-        return t2.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-            return deep.snoc(n1).snoc(n2);
-          }
-        }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-            return deep.snoc(n1).snoc(n2).snoc(single.value());
-          }
-        }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep2) {
-            return new Deep<V, Node<V, A>>(m.nodeMeasured(),
-                                           m.sum(m.sum(m.sum(deep.measure(), n1.measure()), n2.measure()),
-                                                 deep2.measure()), deep.prefix,
-                                           addDigits2(m.nodeMeasured(), deep.middle, deep.suffix, n1, n2, deep2.prefix,
-                                                      deep2.middle), deep2.suffix);
-          }
-        });
-      }
-    });
+    return t1.match(empty -> t2.cons(n2).cons(n1), single -> t2.cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2), single -> deep.snoc(n1).snoc(n2).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(m.nodeMeasured(),
+                                   m.sum(m.sum(m.sum(deep.measure(), n1.measure()), n2.measure()),
+                                         deep2.measure()), deep.prefix,
+                                   addDigits2(m.nodeMeasured(), deep.middle, deep.suffix, n1, n2, deep2.prefix,
+                                              deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits2(final Measured<V, Node<V, A>> m,
@@ -456,103 +350,43 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits2(final Measur
                                                                       final Digit<V, Node<V, A>> prefix,
                                                                       final FingerTree<V, Node<V, Node<V, A>>> m2) {
     final MakeTree<V, Node<V, A>> mk = mkTree(m);
-    return suffix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one2) {
-            return append2(m, m1, mk.node2(one.value(), n1), mk.node2(n2, one2.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(three.values()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()),
-                           m2);
-          }
-        });
-      }
-    }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-        final V2<Node<V, A>> v1 = two.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two2) {
-            final V2<Node<V, A>> v2 = two2.values();
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, v2._1(), v2._2()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, v2._1()), mk.node2(v2._2(), v2._3()),
-                           m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, v2._1(), v2._2()),
-                           mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-        final V3<Node<V, A>> v1 = three.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node3(v1), mk.node3(n1, n2, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(v1), mk.node2(n1, n2), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three2) {
-            final V3<Node<V, A>> v2 = three2.values();
-            return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, v2._1()), mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-        final V4<Node<V, A>> v1 = four.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node2(v1._4(), n1), mk.node2(n2, one.value()),
-                           m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(three.values()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four2) {
-            final V4<Node<V, A>> v2 = four2.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
+    return suffix.match(one -> prefix.match(one2 -> append2(m, m1, mk.node2(one.value(), n1), mk.node2(n2, one2.value()), m2), two -> append2(m, m1, mk.node3(one.value(), n1, n2), mk.node2(two.values()), m2), three -> append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(three.values()), m2), four -> {
+      final V4<Node<V, A>> v2 = four.values();
+      return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()),
+                     m2);
+    }), two -> {
+      final V2<Node<V, A>> v1 = two.values();
+      return prefix.match(one -> append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, one.value()), m2), two2 -> {
+        final V2<Node<V, A>> v2 = two2.values();
+        return append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, v2._1(), v2._2()), m2);
+      }, three -> {
+        final V3<Node<V, A>> v2 = three.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, v2._1()), mk.node2(v2._2(), v2._3()),
+                       m2);
+      }, four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, v2._1(), v2._2()),
+                       mk.node2(v2._3(), v2._4()), m2);
+      });
+    }, three -> {
+      final V3<Node<V, A>> v1 = three.values();
+      return prefix.match(one -> append2(m, m1, mk.node3(v1), mk.node3(n1, n2, one.value()), m2), two -> append3(m, m1, mk.node3(v1), mk.node2(n1, n2), mk.node2(two.values()), m2), three2 -> {
+        final V3<Node<V, A>> v2 = three2.values();
+        return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, v2._1()), mk.node2(v2._2(), v2._3()), m2);
+      }, four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
+      });
+    }, four -> {
+      final V4<Node<V, A>> v1 = four.values();
+      return prefix.match(one -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node2(v1._4(), n1), mk.node2(n2, one.value()),
+                     m2), two -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                     mk.node2(two.values()), m2), three -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                     mk.node3(three.values()), m2), four2 -> {
+        final V4<Node<V, A>> v2 = four2.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                       mk.node2(v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
+      });
     });
   }
 
@@ -561,34 +395,10 @@ private static <V, A> FingerTree<V, Node<V, A>> append3(final Measured<V, A> m,
                                                           final Node<V, A> n1, final Node<V, A> n2, final Node<V, A> n3,
                                                           final FingerTree<V, Node<V, A>> t2) {
     final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-    return t1.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-        return t2.cons(n3).cons(n2).cons(n1);
-      }
-    }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-        return t2.cons(n3).cons(n2).cons(n1).cons(single.value());
-      }
-    }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep) {
-        return t2.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-            return deep.snoc(n1).snoc(n2).snoc(n3);
-          }
-        }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-            return deep.snoc(n1).snoc(n2).snoc(n3).snoc(single.value());
-          }
-        }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep2) {
-            return new Deep<V, Node<V, A>>(nm, nm.monoid().sumLeft(
-                list(deep.v, n1.measure(), n2.measure(), n3.measure(), deep2.v)), deep.prefix,
-                                           addDigits3(nm, deep.middle, deep.suffix, n1, n2, n3, deep2.prefix,
-                                                      deep2.middle), deep2.suffix);
-          }
-        });
-      }
-    });
+    return t1.match(empty -> t2.cons(n3).cons(n2).cons(n1), single -> t2.cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2).snoc(n3), single -> deep.snoc(n1).snoc(n2).snoc(n3).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(nm, nm.monoid().sumLeft(
+        list(deep.v, n1.measure(), n2.measure(), n3.measure(), deep2.v)), deep.prefix,
+                                   addDigits3(nm, deep.middle, deep.suffix, n1, n2, n3, deep2.prefix,
+                                              deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits3(final Measured<V, Node<V, A>> m,
@@ -599,105 +409,47 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits3(final Measur
                                                                       final Digit<V, Node<V, A>> prefix,
                                                                       final FingerTree<V, Node<V, Node<V, A>>> m2) {
     final MakeTree<V, Node<V, A>> mk = mkTree(m);
-    return suffix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one2) {
-            return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, one2.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            final V2<Node<V, A>> v2 = two.values();
-            return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, v2._1(), v2._2()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, v2._1()), mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, v2._1(), v2._2()),
-                           mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-        final V2<Node<V, A>> v1 = two.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, n3), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, v2._1()), mk.node2(v2._2(), v2._3()),
-                           m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, v2._1()),
-                           mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(three.values()), mk.node2(n1, n2), mk.node2(n3, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three2) {
-            return append3(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node3(three2.values()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append4(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node2(v2._1(), v2._2()),
-                           mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-        final V4<Node<V, A>> v1 = four.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node2(n3, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            final V2<Node<V, A>> v2 = two.values();
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(n3, v2._1(), v2._2()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2), mk.node2(n3, v2._1()),
-                           mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four2) {
-            final V4<Node<V, A>> v2 = four2.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(n3, v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
+    return suffix.match(one -> prefix.match(one2 -> append2(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, one2.value()), m2), two -> {
+      final V2<Node<V, A>> v2 = two.values();
+      return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, v2._1(), v2._2()), m2);
+    }, three -> {
+      final V3<Node<V, A>> v2 = three.values();
+      return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, v2._1()), mk.node2(v2._2(), v2._3()), m2);
+    }, four -> {
+      final V4<Node<V, A>> v2 = four.values();
+      return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, v2._1(), v2._2()),
+                     mk.node2(v2._3(), v2._4()), m2);
+    }), two -> {
+      final V2<Node<V, A>> v1 = two.values();
+      return prefix.match(one -> append2(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, one.value()), m2), two1 -> append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, n3), mk.node2(two1.values()), m2), three -> {
+        final V3<Node<V, A>> v2 = three.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, v2._1()), mk.node2(v2._2(), v2._3()),
+                       m2);
+      }, four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, v2._1()),
+                       mk.node3(v2._2(), v2._3(), v2._4()), m2);
+      });
+    }, three -> prefix.match(one -> append3(m, m1, mk.node3(three.values()), mk.node2(n1, n2), mk.node2(n3, one.value()), m2), two -> append3(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node2(two.values()), m2), three2 -> append3(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node3(three2.values()), m2), four -> {
+      final V4<Node<V, A>> v2 = four.values();
+      return append4(m, m1, mk.node3(three.values()), mk.node3(n1, n2, n3), mk.node2(v2._1(), v2._2()),
+                     mk.node2(v2._3(), v2._4()), m2);
+    }), four -> {
+      final V4<Node<V, A>> v1 = four.values();
+      return prefix.match(one -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                     mk.node2(n3, one.value()), m2), two -> {
+        final V2<Node<V, A>> v2 = two.values();
+        return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                       mk.node3(n3, v2._1(), v2._2()), m2);
+      }, three -> {
+        final V3<Node<V, A>> v2 = three.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2), mk.node2(n3, v2._1()),
+                       mk.node2(v2._2(), v2._3()), m2);
+      }, four2 -> {
+        final V4<Node<V, A>> v2 = four2.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                       mk.node3(n3, v2._1(), v2._2()), mk.node2(v2._3(), v2._4()), m2);
+      });
     });
   }
 
@@ -710,34 +462,10 @@ private static <V, A> FingerTree<V, Node<V, A>> append4(final Measured<V, A> m,
                                                           final Node<V, A> n4,
                                                           final FingerTree<V, Node<V, A>> t2) {
     final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-    return t1.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-        return t2.cons(n4).cons(n3).cons(n2).cons(n1);
-      }
-    }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-        return t2.cons(n4).cons(n3).cons(n2).cons(n1).cons(single.value());
-      }
-    }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-      public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep) {
-        return t2.match(new F<Empty<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Empty<V, Node<V, A>> empty) {
-            return t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4);
-          }
-        }, new F<Single<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Single<V, Node<V, A>> single) {
-            return t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4).snoc(single.value());
-          }
-        }, new F<Deep<V, Node<V, A>>, FingerTree<V, Node<V, A>>>() {
-          public FingerTree<V, Node<V, A>> f(final Deep<V, Node<V, A>> deep2) {
-            return new Deep<V, Node<V, A>>(nm, m.monoid().sumLeft(
-                list(deep.v, n1.measure(), n2.measure(), n3.measure(), n4.measure(), deep2.v)), deep.prefix,
-                                           addDigits4(nm, deep.middle, deep.suffix, n1, n2, n3, n4, deep2.prefix,
-                                                      deep2.middle), deep2.suffix);
-          }
-        });
-      }
-    });
+    return t1.match(empty -> t2.cons(n4).cons(n3).cons(n2).cons(n1), single -> t2.cons(n4).cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4), single -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(nm, m.monoid().sumLeft(
+        list(deep.v, n1.measure(), n2.measure(), n3.measure(), n4.measure(), deep2.v)), deep.prefix,
+                                   addDigits4(nm, deep.middle, deep.suffix, n1, n2, n3, n4, deep2.prefix,
+                                              deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits4(final Measured<V, Node<V, A>> m,
@@ -748,106 +476,48 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits4(final Measur
                                                                       final Digit<V, Node<V, A>> prefix,
                                                                       final FingerTree<V, Node<V, Node<V, A>>> m2) {
     final MakeTree<V, Node<V, A>> mk = mkTree(m);
-    return suffix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one2) {
-            return append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, one2.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, n4), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, v2._1()), mk.node2(v2._2(), v2._3()),
-                           m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, v2._1()),
-                           mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-        final V2<Node<V, A>> v1 = two.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, n3), mk.node2(n4, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two2) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node2(two2.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node3(three.values()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node2(v2._1(), v2._2()),
-                           mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-        final V3<Node<V, A>> v1 = three.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node2(n4, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            final V2<Node<V, A>> v2 = two.values();
-            return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node3(n4, v2._1(), v2._2()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append4(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node2(n4, v2._1()), mk.node2(v2._2(), v2._3()),
-                           m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append4(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node3(n4, v2._1(), v2._2()),
-                           mk.node2(v2._3(), v2._4()), m2);
-          }
-        });
-      }
-    }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-      public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-        final V4<Node<V, A>> v1 = four.values();
-        return prefix.match(new F<One<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final One<V, Node<V, A>> one) {
-            return append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(n3, n4, one.value()), m2);
-          }
-        }, new F<Two<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Two<V, Node<V, A>> two) {
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node2(n3, n4), mk.node2(two.values()), m2);
-          }
-        }, new F<Three<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Three<V, Node<V, A>> three) {
-            final V3<Node<V, A>> v2 = three.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(n3, n4, v2._1()), mk.node2(v2._2(), v2._3()), m2);
-          }
-        }, new F<Four<V, Node<V, A>>, FingerTree<V, Node<V, Node<V, A>>>>() {
-          public FingerTree<V, Node<V, Node<V, A>>> f(final Four<V, Node<V, A>> four) {
-            final V4<Node<V, A>> v2 = four.values();
-            return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
-                           mk.node3(n3, n4, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
-          }
-        });
-      }
+    return suffix.match(one -> prefix.match(one2 -> append2(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, one2.value()), m2), two -> append3(m, m1, mk.node3(one.value(), n1, n2), mk.node2(n3, n4), mk.node2(two.values()), m2), three -> {
+      final V3<Node<V, A>> v2 = three.values();
+      return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, v2._1()), mk.node2(v2._2(), v2._3()),
+                     m2);
+    }, four -> {
+      final V4<Node<V, A>> v2 = four.values();
+      return append3(m, m1, mk.node3(one.value(), n1, n2), mk.node3(n3, n4, v2._1()),
+                     mk.node3(v2._2(), v2._3(), v2._4()), m2);
+    }), two -> {
+      final V2<Node<V, A>> v1 = two.values();
+      return prefix.match(one -> append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node2(n2, n3), mk.node2(n4, one.value()), m2), two2 -> append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node2(two2.values()), m2), three -> append3(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node3(three.values()), m2), four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), n1), mk.node3(n2, n3, n4), mk.node2(v2._1(), v2._2()),
+                       mk.node2(v2._3(), v2._4()), m2);
+      });
+    }, three -> {
+      final V3<Node<V, A>> v1 = three.values();
+      return prefix.match(one -> append3(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node2(n4, one.value()), m2), two -> {
+        final V2<Node<V, A>> v2 = two.values();
+        return append3(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node3(n4, v2._1(), v2._2()), m2);
+      }, three1 -> {
+        final V3<Node<V, A>> v2 = three1.values();
+        return append4(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node2(n4, v2._1()), mk.node2(v2._2(), v2._3()),
+                       m2);
+      }, four -> {
+        final V4<Node<V, A>> v2 = four.values();
+        return append4(m, m1, mk.node3(v1), mk.node3(n1, n2, n3), mk.node3(n4, v2._1(), v2._2()),
+                       mk.node2(v2._3(), v2._4()), m2);
+      });
+    }, four -> {
+      final V4<Node<V, A>> v1 = four.values();
+      return prefix.match(one -> append3(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                     mk.node3(n3, n4, one.value()), m2), two -> append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                     mk.node2(n3, n4), mk.node2(two.values()), m2), three -> {
+        final V3<Node<V, A>> v2 = three.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                       mk.node3(n3, n4, v2._1()), mk.node2(v2._2(), v2._3()), m2);
+      }, four1 -> {
+        final V4<Node<V, A>> v2 = four1.values();
+        return append4(m, m1, mk.node3(v1._1(), v1._2(), v1._3()), mk.node3(v1._4(), n1, n2),
+                       mk.node3(n3, n4, v2._1()), mk.node3(v2._2(), v2._3(), v2._4()), m2);
+      });
     });
   }
 }
diff --git a/demo/src/main/java/fj/demo/ChequeWrite.java b/demo/src/main/java/fj/demo/ChequeWrite.java
index d2d07d3d..ee958fc9 100644
--- a/demo/src/main/java/fj/demo/ChequeWrite.java
+++ b/demo/src/main/java/fj/demo/ChequeWrite.java
@@ -111,19 +111,17 @@ static boolean eq(final List<Character> a, final List<Character> b) {
         final List<P2<List<Character>, Integer>> k = split(cs);
         final int c = k.head()._2();
 
-        k.foreachDoEffect(new Effect1<P2<List<Character>, Integer>>() {
-            public void f(final P2<List<Character>, Integer> z) {
-                final List<Character> w = z._1();
-                final int i = z._2();
-
-                if (i == 0 && c > 0 && and(w))
-                    x.snoc(fromString("and"));
-
-                if (existsNotZero(w)) {
-                    x.snoc(show(w));
-                    if (i != 0)
-                        x.snoc(illion(i - 1));
-                }
+        k.foreachDoEffect(z -> {
+            final List<Character> w = z._1();
+            final int i = z._2();
+
+            if (i == 0 && c > 0 && and(w))
+                x.snoc(fromString("and"));
+
+            if (existsNotZero(w)) {
+                x.snoc(show(w));
+                if (i != 0)
+                    x.snoc(illion(i - 1));
             }
         });
 
diff --git a/demo/src/main/java/fj/demo/List_groupBy.java b/demo/src/main/java/fj/demo/List_groupBy.java
index 1dc8866d..f557ec74 100644
--- a/demo/src/main/java/fj/demo/List_groupBy.java
+++ b/demo/src/main/java/fj/demo/List_groupBy.java
@@ -20,9 +20,7 @@ private static void keyDemo() {
     final List<String> words = list("Hello", "World", "how", "are", "your", "doing");
     final TreeMap<Integer, List<String>> lengthMap = words.groupBy(String::length);
 
-    lengthMap.forEach(entry -> {
-      System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2()));
-    });
+    lengthMap.forEach(entry -> System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2())));
   }
 
   private static void keyValueDemo() {
@@ -30,9 +28,7 @@ private static void keyValueDemo() {
     final List<Integer> xs = list(1, 2, 3, 4, 5, 6, 7, 8, 9);
     final TreeMap<Integer, List<String>> result = xs.groupBy(x -> x % 3, Integer::toBinaryString);
 
-    result.forEach(entry -> {
-      System.out.println(String.format("Numbers with reminder %d are %s", entry._1(), entry._2()));
-    });
+    result.forEach(entry -> System.out.println(String.format("Numbers with reminder %d are %s", entry._1(), entry._2())));
   }
 
   private static void keyValueAccDemo() {
@@ -41,8 +37,6 @@ private static void keyValueAccDemo() {
     final TreeMap<Integer, Integer> lengthCounts =
         words.groupBy(String::length, Function.identity(), 0, (word, sum) -> sum + 1, Ord.hashOrd());
 
-    lengthCounts.forEach(entry -> {
-      System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2()));
-    });
+    lengthCounts.forEach(entry -> System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2())));
   }
 }
diff --git a/demo/src/main/java/fj/demo/concurrent/PingPong.java b/demo/src/main/java/fj/demo/concurrent/PingPong.java
index b0b09011..a9109585 100644
--- a/demo/src/main/java/fj/demo/concurrent/PingPong.java
+++ b/demo/src/main/java/fj/demo/concurrent/PingPong.java
@@ -30,15 +30,13 @@ public PingPong(final ExecutorService pool, final int actors, final int pings) {
 
     // This actor gives feedback to the user that work is being done
     // and also terminates the program when all work has been completed.
-    callback = Actor.queueActor(s, new Effect1<Integer>() {
-      public void f(final Integer i) {
-        done++;
-        if (done >= actors) {
-          System.out.println("All done.");
-          pool.shutdown();
-        } else if (actors < 10 || done % (actors / 10) == 0)
-          System.out.println(MessageFormat.format("{0} actors done ({1} total pongs).", done, pings * done));
-      }
+    callback = Actor.queueActor(s, i -> {
+      done++;
+      if (done >= actors) {
+        System.out.println("All done.");
+        pool.shutdown();
+      } else if (actors < 10 || done % (actors / 10) == 0)
+        System.out.println(MessageFormat.format("{0} actors done ({1} total pongs).", done, pings * done));
     });
   }
 
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index 69b27202..dbbd035c 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -92,24 +92,21 @@ public F<Input<char[]>, IterV<char[], Map<String, Integer>>> f(final P2<StringBu
             new P1<F<char[], IterV<char[], Map<String, Integer>>>>() {
               @Override
               public F<char[], IterV<char[], Map<String, Integer>>> _1() {
-                return new F<char[], Iteratee.IterV<char[], Map<String, Integer>>>() {
-                  @Override
-                  public IterV<char[], Map<String, Integer>> f(final char[] e) {
-                    StringBuilder sb = acc._1();
-                    Map<String, Integer> map = acc._2();
-                    for(char c : e) {
-                      if(Character.isWhitespace(c)) {
-                        if(sb.length() > 0) {
-                          map = update(map, sb.toString(), addOne, Integer.valueOf(0));
-                          sb = new StringBuilder();
-                        }
-                      }
-                      else {
-                        sb.append(c);
+                return e -> {
+                  StringBuilder sb = acc._1();
+                  Map<String, Integer> map = acc._2();
+                  for(char c : e) {
+                    if(Character.isWhitespace(c)) {
+                      if(sb.length() > 0) {
+                        map = update(map, sb.toString(), addOne, Integer.valueOf(0));
+                        sb = new StringBuilder();
                       }
                     }
-                    return IterV.cont(step.f(P.p(sb, map)));
+                    else {
+                      sb.append(c);
+                    }
                   }
+                  return IterV.cont(step.f(P.p(sb, map)));
                 };
               }
             };
@@ -139,25 +136,23 @@ public static final <E> IterV<Character, Map<String, Integer>> wordCountsFromCha
         public F<Input<Character>, IterV<Character, Map<String, Integer>>> f(final P2<StringBuilder,Map<String, Integer>> acc) {
           final P1<IterV<Character, Map<String, Integer>>> empty = P.lazy(() -> IterV.cont(step.f(acc)));
           final P1<F<Character, IterV<Character, Map<String, Integer>>>> el =
-            P.lazy(() -> {
-                return e -> {
-                    if(Character.isWhitespace(e.charValue())) {
-                      final StringBuilder sb = acc._1();
-                      if(sb.length() > 0) {
-                        final Map<String, Integer> map = update(acc._2(), sb.toString(), addOne, Integer.valueOf(0));
-                        return IterV.cont(step.f(P.p(new StringBuilder(), map)));
-                      }
-                      else {
-                        // another whitespace char, no word to push to the map
-                        return IterV.cont(step.f(acc));
-                      }
-                    }
-                    else {
-                      acc._1().append(e);
-                      return IterV.cont(step.f(acc));
-                    }
-                };
-              });
+            P.lazy(() -> e -> {
+                if(Character.isWhitespace(e.charValue())) {
+                  final StringBuilder sb = acc._1();
+                  if(sb.length() > 0) {
+                    final Map<String, Integer> map = update(acc._2(), sb.toString(), addOne, Integer.valueOf(0));
+                    return IterV.cont(step.f(P.p(new StringBuilder(), map)));
+                  }
+                  else {
+                    // another whitespace char, no word to push to the map
+                    return IterV.cont(step.f(acc));
+                  }
+                }
+                else {
+                  acc._1().append(e);
+                  return IterV.cont(step.f(acc));
+                }
+            });
           final P1<IterV<Character, Map<String, Integer>>> eof = P.lazy(() -> {
                 final StringBuilder sb = acc._1();
                 if(sb.length() > 0) {
@@ -261,12 +256,7 @@ public static void main(String[] args) throws IOException {
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
     
     // we have tmpfiles, but still want to be sure not to leave rubbish
-    fileNames.foreachDoEffect(new Effect1<String>() {
-        @Override
-        public void f(final String a) {
-            new File(a).delete();
-        }
-    });
+    fileNames.foreachDoEffect(a -> new File(a).delete());
   }
 
   @SuppressWarnings("unused")
diff --git a/demo/src/main/java/fj/demo/euler/Problem2.java b/demo/src/main/java/fj/demo/euler/Problem2.java
index 321a34b7..eda4a72d 100644
--- a/demo/src/main/java/fj/demo/euler/Problem2.java
+++ b/demo/src/main/java/fj/demo/euler/Problem2.java
@@ -29,10 +29,7 @@ public Stream<Integer> f(final Integer a, final Integer b) {
 		out.println(sum(fibs.filter(even).takeWhile(intOrd.isLessThan(4000001)).toList()));
 	}
 
-	static F2<Integer, Integer, Stream<Integer>> fibsJava8 = (a, b) -> {
-
-		return cons(a, F1Functions.lazy(F2Functions.curry(Problem2.fibsJava8).f(b)).f(a + b));
-	};
+	static F2<Integer, Integer, Stream<Integer>> fibsJava8 = (a, b) -> cons(a, F1Functions.lazy(F2Functions.curry(Problem2.fibsJava8).f(b)).f(a + b));
 
 	static void java8() {
 		out.println(sum(fibsJava8.f(1, 2).filter(even).takeWhile(intOrd.isLessThan(4000001)).toList()));
diff --git a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
index 03095e80..8ed7a306 100644
--- a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
+++ b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
@@ -52,11 +52,9 @@ public final class ListFunctorLaws {
   // composition: OK, passed 1000 tests.
   @SuppressWarnings("unchecked")
   public static void main(final String[] args) {
-    check(ListFunctorLaws.class).foreachDoEffect(new Effect1<P2<String, CheckResult>>() {
-        public void f(final P2<String, CheckResult> r) {
-            System.out.print(r._1() + ": ");
-            summary.println(r._2());
-        }
+    check(ListFunctorLaws.class).foreachDoEffect(r -> {
+        System.out.print(r._1() + ": ");
+        summary.println(r._2());
     });
   }
 }
diff --git a/demo/src/main/java/fj/demo/test/Reflect.java b/demo/src/main/java/fj/demo/test/Reflect.java
index d5ebfd36..78084b47 100644
--- a/demo/src/main/java/fj/demo/test/Reflect.java
+++ b/demo/src/main/java/fj/demo/test/Reflect.java
@@ -119,11 +119,9 @@ public static void main(final String[] args) {
   }
 
   private static void printResults(final List<P2<String,CheckResult>> results) {
-    results.foreachDoEffect(new Effect1<P2<String, CheckResult>>() {
-        public void f(final P2<String, CheckResult> result) {
-            summary.print(result._2());
-            out.println(" (" + result._1() + ')');
-        }
+    results.foreachDoEffect(result -> {
+        summary.print(result._2());
+        out.println(" (" + result._1() + ')');
     });
     out.println("--------------------------------------------------------------------------------");
   }
diff --git a/demo/src/main/java/fj/demo/test/StringBuilderReverse.java b/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
index b0897044..78a4cc82 100644
--- a/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
+++ b/demo/src/main/java/fj/demo/test/StringBuilderReverse.java
@@ -34,10 +34,6 @@ public static void main(final String[] args) {
     //OK, passed 100 tests.
     //OK, passed 100 tests.
     //OK, passed 100 tests.
-    list(p1, p2, p3).foreachDoEffect(new Effect1<Property>() {
-        public void f(final Property p) {
-            summary.println(p.check());
-        }
-    });
+    list(p1, p2, p3).foreachDoEffect(p -> summary.println(p.check()));
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 7b96d299..a9f05549 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -397,11 +397,7 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
   /**
    * An arbitrary implementation for integer values.
    */
-  public static final Arbitrary<Integer> arbInteger = arbitrary(sized(new F<Integer, Gen<Integer>>() {
-    public Gen<Integer> f(final Integer i) {
-      return choose(-i, i);
-    }
-  }));
+  public static final Arbitrary<Integer> arbInteger = arbitrary(sized(i -> choose(-i, i)));
 
   /**
    * An arbitrary implementation for integer values that checks boundary values <code>(0, 1, -1,
@@ -426,15 +422,7 @@ public Gen<Integer> f(final Integer i) {
    * An arbitrary implementation for long values.
    */
   public static final Arbitrary<Long> arbLong =
-      arbitrary(arbInteger.gen.bind(arbInteger.gen, new F<Integer, F<Integer, Long>>() {
-        public F<Integer, Long> f(final Integer i1) {
-          return new F<Integer, Long>() {
-            public Long f(final Integer i2) {
-              return (long) i1 << 32L & i2;
-            }
-          };
-        }
-      }));
+      arbitrary(arbInteger.gen.bind(arbInteger.gen, i1 -> i2 -> (long) i1 << 32L & i2));
 
   /**
    * An arbitrary implementation for long values that checks boundary values <code>(0, 1, -1, max,
@@ -458,11 +446,7 @@ public Gen<Long> f(final Integer i) {
   /**
    * An arbitrary implementation for byte values.
    */
-  public static final Arbitrary<Byte> arbByte = arbitrary(arbInteger.gen.map(new F<Integer, Byte>() {
-    public Byte f(final Integer i) {
-      return (byte) i.intValue();
-    }
-  }));
+  public static final Arbitrary<Byte> arbByte = arbitrary(arbInteger.gen.map(i -> (byte) i.intValue()));
 
   /**
    * An arbitrary implementation for byte values that checks boundary values <code>(0, 1, -1, max,
@@ -486,11 +470,7 @@ public Gen<Byte> f(final Integer i) {
   /**
    * An arbitrary implementation for short values.
    */
-  public static final Arbitrary<Short> arbShort = arbitrary(arbInteger.gen.map(new F<Integer, Short>() {
-    public Short f(final Integer i) {
-      return (short) i.intValue();
-    }
-  }));
+  public static final Arbitrary<Short> arbShort = arbitrary(arbInteger.gen.map(i -> (short) i.intValue()));
 
   /**
    * An arbitrary implementation for short values that checks boundary values <code>(0, 1, -1, max,
@@ -514,11 +494,7 @@ public Gen<Short> f(final Integer i) {
   /**
    * An arbitrary implementation for character values.
    */
-  public static final Arbitrary<Character> arbCharacter = arbitrary(choose(0, 65536).map(new F<Integer, Character>() {
-    public Character f(final Integer i) {
-      return (char) i.intValue();
-    }
-  }));
+  public static final Arbitrary<Character> arbCharacter = arbitrary(choose(0, 65536).map(i -> (char) i.intValue()));
 
   /**
    * An arbitrary implementation for character values that checks boundary values <code>(max, min,
@@ -539,11 +515,7 @@ public Gen<Character> f(final Integer i) {
   /**
    * An arbitrary implementation for double values.
    */
-  public static final Arbitrary<Double> arbDouble = arbitrary(sized(new F<Integer, Gen<Double>>() {
-    public Gen<Double> f(final Integer i) {
-      return choose((double) -i, i);
-    }
-  }));
+  public static final Arbitrary<Double> arbDouble = arbitrary(sized(i -> choose((double) -i, i)));
 
   /**
    * An arbitrary implementation for double values that checks boundary values <code>(0, 1, -1, max,
@@ -569,11 +541,7 @@ public Gen<Double> f(final Integer i) {
   /**
    * An arbitrary implementation for float values.
    */
-  public static final Arbitrary<Float> arbFloat = arbitrary(arbDouble.gen.map(new F<Double, Float>() {
-    public Float f(final Double d) {
-      return (float) d.doubleValue();
-    }
-  }));
+  public static final Arbitrary<Float> arbFloat = arbitrary(arbDouble.gen.map(d -> (float) d.doubleValue()));
 
   /**
    * An arbitrary implementation for float values that checks boundary values <code>(0, 1, -1, max,
@@ -606,15 +574,7 @@ public Gen<Float> f(final Integer i) {
    * An arbitrary implementation for string values with characters in the US-ASCII range.
    */
   public static final Arbitrary<String> arbUSASCIIString =
-      arbitrary(arbList(arbCharacter).gen.map(new F<List<Character>, String>() {
-        public String f(final List<Character> cs) {
-          return asString(cs.map(new F<Character, Character>() {
-            public Character f(final Character c) {
-              return (char) (c % 128);
-            }
-          }));
-        }
-      }));
+      arbitrary(arbList(arbCharacter).gen.map(cs -> asString(cs.map(c -> (char) (c % 128)))));
 
   /**
    * An arbitrary implementation for string values with alpha-numeric characters.
@@ -643,14 +603,11 @@ public Character f(final Character c) {
    * @return An arbitrary implementation for generators.
    */
   public static <A> Arbitrary<Gen<A>> arbGen(final Arbitrary<A> aa) {
-    return arbitrary(sized(new F<Integer, Gen<Gen<A>>>() {
-      @SuppressWarnings("IfMayBeConditional")
-      public Gen<Gen<A>> f(final Integer i) {
-        if (i == 0)
-          return fail();
-        else
-          return aa.gen.map(Gen::value).resize(i - 1);
-      }
+    return arbitrary(sized(i -> {
+      if (i == 0)
+        return fail();
+      else
+        return aa.gen.map(Gen::value).resize(i - 1);
     }));
   }
 
@@ -661,13 +618,9 @@ public Gen<Gen<A>> f(final Integer i) {
    * @return An arbitrary implementation for optional values.
    */
   public static <A> Arbitrary<Option<A>> arbOption(final Arbitrary<A> aa) {
-    return arbitrary(sized(new F<Integer, Gen<Option<A>>>() {
-      public Gen<Option<A>> f(final Integer i) {
-        return i == 0 ?
-               value(Option.<A>none()) :
-               aa.gen.map(Option::some).resize(i - 1);
-      }
-    }));
+    return arbitrary(sized(i -> i == 0 ?
+           value(Option.<A>none()) :
+           aa.gen.map(Option::some).resize(i - 1)));
   }
 
   /**
@@ -800,38 +753,26 @@ public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
    * @return An arbitrary implementation for array lists.
    */
   public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, ArrayList<A>>() {
-      public ArrayList<A> f(final Array<A> a) {
-        return new ArrayList<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new ArrayList<A>(a.toCollection())));
   }
 
   /**
    * An arbitrary implementation for bit sets.
    */
   public static final Arbitrary<BitSet> arbBitSet =
-      arbitrary(arbList(arbBoolean).gen.map(new F<List<Boolean>, BitSet>() {
-        public BitSet f(final List<Boolean> bs) {
-          final BitSet s = new BitSet(bs.length());
-          bs.zipIndex().foreachDoEffect(new Effect1<P2<Boolean, Integer>>() {
-              public void f(final P2<Boolean, Integer> bi) {
-                  s.set(bi._2(), bi._1());
-              }
-          });
-          return s;
-        }
+      arbitrary(arbList(arbBoolean).gen.map(bs -> {
+        final BitSet s = new BitSet(bs.length());
+        bs.zipIndex().foreachDoEffect(bi -> s.set(bi._2(), bi._1()));
+        return s;
       }));
 
   /**
    * An arbitrary implementation for calendars.
    */
-  public static final Arbitrary<Calendar> arbCalendar = arbitrary(arbLong.gen.map(new F<Long, Calendar>() {
-    public Calendar f(final Long i) {
-      final Calendar c = Calendar.getInstance();
-      c.setTimeInMillis(i);
-      return c;
-    }
+  public static final Arbitrary<Calendar> arbCalendar = arbitrary(arbLong.gen.map(i -> {
+    final Calendar c = Calendar.getInstance();
+    c.setTimeInMillis(i);
+    return c;
   }));
 
   /**
@@ -869,23 +810,17 @@ public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final A
    * @return An arbitrary implementation for enum sets.
    */
   public static <A extends Enum<A>> Arbitrary<EnumSet<A>> arbEnumSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, EnumSet<A>>() {
-      public EnumSet<A> f(final Array<A> a) {
-        return copyOf(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.toCollection())));
   }
 
   /**
    * An arbitrary implementation for gregorian calendars.
    */
   public static final Arbitrary<GregorianCalendar> arbGregorianCalendar =
-      arbitrary(arbLong.gen.map(new F<Long, GregorianCalendar>() {
-        public GregorianCalendar f(final Long i) {
-          final GregorianCalendar c = new GregorianCalendar();
-          c.setTimeInMillis(i);
-          return c;
-        }
+      arbitrary(arbLong.gen.map(i -> {
+        final GregorianCalendar c = new GregorianCalendar();
+        c.setTimeInMillis(i);
+        return c;
       }));
 
   /**
@@ -907,11 +842,7 @@ public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak,
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, HashSet<A>>() {
-      public HashSet<A> f(final Array<A> a) {
-        return new HashSet<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<A>(a.toCollection())));
   }
 
   /**
@@ -924,23 +855,12 @@ public HashSet<A> f(final Array<A> a) {
    * @return An arbitrary implementation for hash tables.
    */
   public static <K, V> Arbitrary<Hashtable<K, V>> arbHashtable(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbList(ak).gen.bind(arbList(av).gen, new F<List<K>, F<List<V>, Hashtable<K, V>>>() {
-      public F<List<V>, Hashtable<K, V>> f(final List<K> ks) {
-        return new F<List<V>, Hashtable<K, V>>() {
-          @SuppressWarnings("UseOfObsoleteCollectionType")
-          public Hashtable<K, V> f(final List<V> vs) {
-            final Hashtable<K, V> t = new Hashtable<K, V>();
-
-            ks.zip(vs).foreachDoEffect(new Effect1<P2<K, V>>() {
-                public void f(final P2<K, V> kv) {
-                    t.put(kv._1(), kv._2());
-                }
-            });
-
-            return t;
-          }
-        };
-      }
+    return arbitrary(arbList(ak).gen.bind(arbList(av).gen, ks -> vs -> {
+      final Hashtable<K, V> t = new Hashtable<K, V>();
+
+      ks.zip(vs).foreachDoEffect(kv -> t.put(kv._1(), kv._2()));
+
+      return t;
     }));
   }
 
@@ -978,11 +898,7 @@ public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbit
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, LinkedHashSet<A>>() {
-      public LinkedHashSet<A> f(final Array<A> a) {
-        return new LinkedHashSet<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<A>(a.toCollection())));
   }
 
   /**
@@ -992,11 +908,7 @@ public LinkedHashSet<A> f(final Array<A> a) {
    * @return An arbitrary implementation for linked lists.
    */
   public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, LinkedList<A>>() {
-      public LinkedList<A> f(final Array<A> a) {
-        return new LinkedList<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<A>(a.toCollection())));
   }
 
   /**
@@ -1006,28 +918,21 @@ public LinkedList<A> f(final Array<A> a) {
    * @return An arbitrary implementation for priority queues.
    */
   public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, PriorityQueue<A>>() {
-      public PriorityQueue<A> f(final Array<A> a) {
-        return new PriorityQueue<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<A>(a.toCollection())));
   }
 
   /**
    * An arbitrary implementation for properties.
    */
   public static final Arbitrary<Properties> arbProperties =
-      arbitrary(arbHashtable(arbString, arbString).gen.map(new F<Hashtable<String, String>, Properties>() {
-        @SuppressWarnings("UseOfObsoleteCollectionType")
-        public Properties f(final Hashtable<String, String> ht) {
-          final Properties p = new Properties();
+      arbitrary(arbHashtable(arbString, arbString).gen.map(ht -> {
+        final Properties p = new Properties();
 
-          for (final String k : ht.keySet()) {
-            p.setProperty(k, ht.get(k));
-          }
-
-          return p;
+        for (final String k : ht.keySet()) {
+          p.setProperty(k, ht.get(k));
         }
+
+        return p;
       }));
 
   /**
@@ -1037,12 +942,10 @@ public Properties f(final Hashtable<String, String> ht) {
    * @return An arbitrary implementation for stacks.
    */
   public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, Stack<A>>() {
-      public Stack<A> f(final Array<A> a) {
-        final Stack<A> s = new Stack<A>();
-        s.addAll(a.toCollection());
-        return s;
-      }
+    return arbitrary(arbArray(aa).gen.map(a -> {
+      final Stack<A> s = new Stack<A>();
+      s.addAll(a.toCollection());
+      return s;
     }));
   }
 
@@ -1102,11 +1005,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
    * @return An arbitrary implementation for tree sets.
    */
   public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, TreeSet<A>>() {
-      public TreeSet<A> f(final Array<A> a) {
-        return new TreeSet<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<A>(a.toCollection())));
   }
 
   /**
@@ -1117,12 +1016,7 @@ public TreeSet<A> f(final Array<A> a) {
    */
   @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, Vector<A>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public Vector<A> f(final Array<A> a) {
-        return new Vector<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new Vector<A>(a.toCollection())));
   }
 
   /**
@@ -1151,20 +1045,8 @@ public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary
    */
   public static <A> Arbitrary<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.bind(arbInteger.gen, arbBoolean.gen,
-                                           new F<Array<A>, F<Integer, F<Boolean, ArrayBlockingQueue<A>>>>() {
-                                             public F<Integer, F<Boolean, ArrayBlockingQueue<A>>> f(final Array<A> a) {
-                                               return new F<Integer, F<Boolean, ArrayBlockingQueue<A>>>() {
-                                                 public F<Boolean, ArrayBlockingQueue<A>> f(final Integer capacity) {
-                                                   return new F<Boolean, ArrayBlockingQueue<A>>() {
-                                                     public ArrayBlockingQueue<A> f(final Boolean fair) {
-                                                       return new ArrayBlockingQueue<A>(a.length() + abs(capacity),
-                                                                                        fair, a.toCollection());
-                                                     }
-                                                   };
-                                                 }
-                                               };
-                                             }
-                                           }));
+        a -> capacity -> fair -> new ArrayBlockingQueue<A>(a.length() + abs(capacity),
+                                         fair, a.toCollection())));
   }
 
   /**
@@ -1189,11 +1071,7 @@ public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(fin
    * @return An arbitrary implementation for concurrent linked queues.
    */
   public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, ConcurrentLinkedQueue<A>>() {
-      public ConcurrentLinkedQueue<A> f(final Array<A> a) {
-        return new ConcurrentLinkedQueue<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<A>(a.toCollection())));
   }
 
   /**
@@ -1204,11 +1082,7 @@ public ConcurrentLinkedQueue<A> f(final Array<A> a) {
    * @return An arbitrary implementation for copy-on-write array lists.
    */
   public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, CopyOnWriteArrayList<A>>() {
-      public CopyOnWriteArrayList<A> f(final Array<A> a) {
-        return new CopyOnWriteArrayList<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<A>(a.toCollection())));
   }
 
   /**
@@ -1219,11 +1093,7 @@ public CopyOnWriteArrayList<A> f(final Array<A> a) {
    * @return An arbitrary implementation for copy-on-write array sets.
    */
   public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, CopyOnWriteArraySet<A>>() {
-      public CopyOnWriteArraySet<A> f(final Array<A> a) {
-        return new CopyOnWriteArraySet<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<A>(a.toCollection())));
   }
 
   /**
@@ -1233,11 +1103,7 @@ public CopyOnWriteArraySet<A> f(final Array<A> a) {
    * @return An arbitrary implementation for delay queues.
    */
   public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, DelayQueue<A>>() {
-      public DelayQueue<A> f(final Array<A> a) {
-        return new DelayQueue<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<A>(a.toCollection())));
   }
 
   /**
@@ -1248,11 +1114,7 @@ public DelayQueue<A> f(final Array<A> a) {
    * @return An arbitrary implementation for linked blocking queues.
    */
   public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, LinkedBlockingQueue<A>>() {
-      public LinkedBlockingQueue<A> f(final Array<A> a) {
-        return new LinkedBlockingQueue<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<A>(a.toCollection())));
   }
 
   /**
@@ -1263,11 +1125,7 @@ public LinkedBlockingQueue<A> f(final Array<A> a) {
    * @return An arbitrary implementation for priority blocking queues.
    */
   public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(new F<Array<A>, PriorityBlockingQueue<A>>() {
-      public PriorityBlockingQueue<A> f(final Array<A> a) {
-        return new PriorityBlockingQueue<A>(a.toCollection());
-      }
-    }));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<A>(a.toCollection())));
   }
 
   /**
@@ -1278,16 +1136,10 @@ public PriorityBlockingQueue<A> f(final Array<A> a) {
    * @return An arbitrary implementation for priority blocking queues.
    */
   public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, new F<Array<A>, F<Boolean, SynchronousQueue<A>>>() {
-      public F<Boolean, SynchronousQueue<A>> f(final Array<A> a) {
-        return new F<Boolean, SynchronousQueue<A>>() {
-          public SynchronousQueue<A> f(final Boolean fair) {
-            final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
-            q.addAll(a.toCollection());
-            return q;
-          }
-        };
-      }
+    return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, a -> fair -> {
+      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      q.addAll(a.toCollection());
+      return q;
     }));
   }
 
@@ -1318,22 +1170,16 @@ public SynchronousQueue<A> f(final Boolean fair) {
    * An arbitrary implementation for big integers.
    */
   public static final Arbitrary<BigInteger> arbBigInteger =
-      arbitrary(arbArray(arbByte).gen.bind(arbByte.gen, new F<Array<Byte>, F<Byte, BigInteger>>() {
-        public F<Byte, BigInteger> f(final Array<Byte> a) {
-          return new F<Byte, BigInteger>() {
-            public BigInteger f(final Byte b) {
-              final byte[] x = new byte[a.length() + 1];
+      arbitrary(arbArray(arbByte).gen.bind(arbByte.gen, a -> b -> {
+        final byte[] x = new byte[a.length() + 1];
 
-              for (int i = 0; i < a.array().length; i++) {
-                x[i] = a.get(i);
-              }
+        for (int i = 0; i < a.array().length; i++) {
+          x[i] = a.get(i);
+        }
 
-              x[a.length()] = b;
+        x[a.length()] = b;
 
-              return new BigInteger(x);
-            }
-          };
-        }
+        return new BigInteger(x);
       }));
 
   /**
@@ -1369,15 +1215,7 @@ public static <A> Arbitrary<P1<A>> arbP1(final Arbitrary<A> aa) {
    * @return An arbitrary implementation for product-2 values.
    */
   public static <A, B> Arbitrary<P2<A, B>> arbP2(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-    return arbitrary(aa.gen.bind(ab.gen, new F<A, F<B, P2<A, B>>>() {
-      public F<B, P2<A, B>> f(final A a) {
-        return new F<B, P2<A, B>>() {
-          public P2<A, B> f(final B b) {
-            return p(a, b);
-          }
-        };
-      }
-    }));
+    return arbitrary(aa.gen.bind(ab.gen, a -> b -> p(a, b)));
   }
 
   /**
@@ -1393,19 +1231,7 @@ public P2<A, B> f(final B b) {
    */
   public static <A, B, C> Arbitrary<P3<A, B, C>> arbP3(final Arbitrary<A> aa, final Arbitrary<B> ab,
                                                        final Arbitrary<C> ac) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, new F<A, F<B, F<C, P3<A, B, C>>>>() {
-      public F<B, F<C, P3<A, B, C>>> f(final A a) {
-        return new F<B, F<C, P3<A, B, C>>>() {
-          public F<C, P3<A, B, C>> f(final B b) {
-            return new F<C, P3<A, B, C>>() {
-              public P3<A, B, C> f(final C c) {
-                return p(a, b, c);
-              }
-            };
-          }
-        };
-      }
-    }));
+    return arbitrary(aa.gen.bind(ab.gen, ac.gen, a -> b -> c -> p(a, b, c)));
   }
 
   /**
@@ -1423,23 +1249,7 @@ public P3<A, B, C> f(final C c) {
    */
   public static <A, B, C, D> Arbitrary<P4<A, B, C, D>> arbP4(final Arbitrary<A> aa, final Arbitrary<B> ab,
                                                              final Arbitrary<C> ac, final Arbitrary<D> ad) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, new F<A, F<B, F<C, F<D, P4<A, B, C, D>>>>>() {
-      public F<B, F<C, F<D, P4<A, B, C, D>>>> f(final A a) {
-        return new F<B, F<C, F<D, P4<A, B, C, D>>>>() {
-          public F<C, F<D, P4<A, B, C, D>>> f(final B b) {
-            return new F<C, F<D, P4<A, B, C, D>>>() {
-              public F<D, P4<A, B, C, D>> f(final C c) {
-                return new F<D, P4<A, B, C, D>>() {
-                  public P4<A, B, C, D> f(final D d) {
-                    return p(a, b, c, d);
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    }));
+    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, a -> b -> c -> d -> p(a, b, c, d)));
   }
 
   /**
@@ -1460,27 +1270,7 @@ public P4<A, B, C, D> f(final D d) {
   public static <A, B, C, D, E> Arbitrary<P5<A, B, C, D, E>> arbP5(final Arbitrary<A> aa, final Arbitrary<B> ab,
                                                                    final Arbitrary<C> ac, final Arbitrary<D> ad,
                                                                    final Arbitrary<E> ae) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, new F<A, F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>>>() {
-      public F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, P5<A, B, C, D, E>>>>>() {
-          public F<C, F<D, F<E, P5<A, B, C, D, E>>>> f(final B b) {
-            return new F<C, F<D, F<E, P5<A, B, C, D, E>>>>() {
-              public F<D, F<E, P5<A, B, C, D, E>>> f(final C c) {
-                return new F<D, F<E, P5<A, B, C, D, E>>>() {
-                  public F<E, P5<A, B, C, D, E>> f(final D d) {
-                    return new F<E, P5<A, B, C, D, E>>() {
-                      public P5<A, B, C, D, E> f(final E e) {
-                        return p(a, b, c, d, e);
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    }));
+    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, a -> b -> c -> d -> e -> p(a, b, c, d, e)));
   }
 
   /**
@@ -1505,31 +1295,7 @@ public P5<A, B, C, D, E> f(final E e) {
                                                                            final Arbitrary<E> ae,
                                                                            final Arbitrary<F$> af) {
     return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen,
-                                 new F<A, F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>>>() {
-                                   public F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>> f(final A a) {
-                                     return new F<B, F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>>() {
-                                       public F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>> f(final B b) {
-                                         return new F<C, F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>>() {
-                                           public F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>> f(final C c) {
-                                             return new F<D, F<E, F<F$, P6<A, B, C, D, E, F$>>>>() {
-                                               public F<E, F<F$, P6<A, B, C, D, E, F$>>> f(final D d) {
-                                                 return new F<E, F<F$, P6<A, B, C, D, E, F$>>>() {
-                                                   public F<F$, P6<A, B, C, D, E, F$>> f(final E e) {
-                                                     return new F<F$, P6<A, B, C, D, E, F$>>() {
-                                                       public P6<A, B, C, D, E, F$> f(final F$ f) {
-                                                         return p(a, b, c, d, e, f);
-                                                       }
-                                                     };
-                                                   }
-                                                 };
-                                               }
-                                             };
-                                           }
-                                         };
-                                       }
-                                     };
-                                   }
-                                 }));
+        a -> b -> c -> d -> e -> f -> p(a, b, c, d, e, f)));
   }
 
   /**
@@ -1559,35 +1325,7 @@ public P5<A, B, C, D, E> f(final E e) {
                                                                                  final Arbitrary<F$> af,
                                                                                  final Arbitrary<G> ag) {
     return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen, ag.gen,
-                                 new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>>>() {
-                                   public F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>> f(final A a) {
-                                     return new F<B, F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>>() {
-                                       public F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>> f(final B b) {
-                                         return new F<C, F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>>() {
-                                           public F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>> f(final C c) {
-                                             return new F<D, F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>>() {
-                                               public F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>> f(final D d) {
-                                                 return new F<E, F<F$, F<G, P7<A, B, C, D, E, F$, G>>>>() {
-                                                   public F<F$, F<G, P7<A, B, C, D, E, F$, G>>> f(final E e) {
-                                                     return new F<F$, F<G, P7<A, B, C, D, E, F$, G>>>() {
-                                                       public F<G, P7<A, B, C, D, E, F$, G>> f(final F$ f) {
-                                                         return new F<G, P7<A, B, C, D, E, F$, G>>() {
-                                                           public P7<A, B, C, D, E, F$, G> f(final G g) {
-                                                             return p(a, b, c, d, e, f, g);
-                                                           }
-                                                         };
-                                                       }
-                                                     };
-                                                   }
-                                                 };
-                                               }
-                                             };
-                                           }
-                                         };
-                                       }
-                                     };
-                                   }
-                                 }));
+        a -> b -> c -> d -> e -> f -> g -> p(a, b, c, d, e, f, g)));
   }
 
   /**
@@ -1620,42 +1358,6 @@ public P5<A, B, C, D, E> f(final E e) {
                                                                                        final Arbitrary<G> ag,
                                                                                        final Arbitrary<H> ah) {
     return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen, ag.gen, ah.gen,
-                                 new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>>>() {
-                                   public F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>> f(
-                                       final A a) {
-                                     return new F<B, F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>>() {
-                                       public F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>> f(
-                                           final B b) {
-                                         return new F<C, F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>>() {
-                                           public F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>> f(
-                                               final C c) {
-                                             return new F<D, F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>>() {
-                                               public F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>> f(
-                                                   final D d) {
-                                                 return new F<E, F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>>() {
-                                                   public F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>> f(final E e) {
-                                                     return new F<F$, F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>>() {
-                                                       public F<G, F<H, P8<A, B, C, D, E, F$, G, H>>> f(final F$ f) {
-                                                         return new F<G, F<H, P8<A, B, C, D, E, F$, G, H>>>() {
-                                                           public F<H, P8<A, B, C, D, E, F$, G, H>> f(final G g) {
-                                                             return new F<H, P8<A, B, C, D, E, F$, G, H>>() {
-                                                               public P8<A, B, C, D, E, F$, G, H> f(final H h) {
-                                                                 return p(a, b, c, d, e, f, g, h);
-                                                               }
-                                                             };
-                                                           }
-                                                         };
-                                                       }
-                                                     };
-                                                   }
-                                                 };
-                                               }
-                                             };
-                                           }
-                                         };
-                                       }
-                                     };
-                                   }
-                                 }));
+        a -> b -> c -> d -> e -> f -> g -> h -> p(a, b, c, d, e, f, g, h)));
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index bb607aa5..9655aec2 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -76,11 +76,7 @@ public abstract class Coarbitrary<A> {
    * @return A curried version of {@link #coarbitrary(Object, Gen)}.
    */
   public final <B> F<Gen<B>, Gen<B>> coarbitrary(final A a) {
-    return new F<Gen<B>, Gen<B>>() {
-      public Gen<B> f(final Gen<B> g) {
-        return coarbitrary(a, g);
-      }
-    };
+    return g -> coarbitrary(a, g);
   }
 
   /**
@@ -121,11 +117,7 @@ public <X> Gen<X> coarbitrary(final B b, final Gen<X> g) {
   public static <A, B> Coarbitrary<F<A, B>> coarbF(final Arbitrary<A> a, final Coarbitrary<B> c) {
     return new Coarbitrary<F<A, B>>() {
       public <X> Gen<X> coarbitrary(final F<A, B> f, final Gen<X> g) {
-        return a.gen.bind(new F<A, Gen<X>>() {
-          public Gen<X> f(final A a) {
-            return c.coarbitrary(f.f(a), g);
-          }
-        });
+        return a.gen.bind(a1 -> c.coarbitrary(f.f(a1), g));
       }
     };
   }
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index b3bb1371..45a4429a 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -110,15 +110,7 @@ public A gen(final int i, final Rand r) {
    * @return A new generator after applying the mapping function.
    */
   public <B> Gen<B> map(final F<A, B> f) {
-    return new Gen<B>(new F<Integer, F<Rand, B>>() {
-      public F<Rand, B> f(final Integer i) {
-        return new F<Rand, B>() {
-          public B f(final Rand r) {
-            return f.f(gen(i, r));
-          }
-        };
-      }
-    });
+    return new Gen<B>(i -> r -> f.f(gen(i, r)));
   }
 
   /**
@@ -169,15 +161,7 @@ public void foreachDoEffect(final Integer i, final Rand r, final Effect1<A> f) {
    * @return A new generator after binding the given function.
    */
   public <B> Gen<B> bind(final F<A, Gen<B>> f) {
-    return new Gen<B>(new F<Integer, F<Rand, B>>() {
-      public F<Rand, B> f(final Integer i) {
-        return new F<Rand, B>() {
-          public B f(final Rand r) {
-            return f.f(gen(i, r)).f.f(i).f(r);
-          }
-        };
-      }
-    });
+    return new Gen<B>(i -> r -> f.f(gen(i, r)).f.f(i).f(r));
   }
 
   /**
@@ -292,11 +276,7 @@ public <B, C, D, E> Gen<E> bind(final Gen<B> gb, final Gen<C> gc, final Gen<D> g
    * @return A new generator after function application.
    */
   public <B> Gen<B> apply(final Gen<F<A, B>> gf) {
-    return gf.bind(new F<F<A, B>, Gen<B>>() {
-      public Gen<B> f(final F<A, B> f) {
-        return map(f::f);
-      }
-    });
+    return gf.bind(f1 -> map(f1::f));
   }
 
   /**
@@ -306,15 +286,7 @@ public Gen<B> f(final F<A, B> f) {
    * @return A new generator that uses the given size.
    */
   public Gen<A> resize(final int s) {
-    return new Gen<A>(new F<Integer, F<Rand, A>>() {
-      public F<Rand, A> f(final Integer i) {
-        return new F<Rand, A>() {
-          public A f(final Rand r) {
-            return f.f(s).f(r);
-          }
-        };
-      }
-    });
+    return new Gen<A>(i -> r -> f.f(s).f(r));
   }
 
   /**
@@ -376,15 +348,7 @@ public static <A> Gen<A> sized(final F<Integer, Gen<A>> f) {
    * @return A generator that always produces the given value.
    */
   public static <A> Gen<A> value(final A a) {
-    return new Gen<A>(new F<Integer, F<Rand, A>>() {
-      public F<Rand, A> f(final Integer i) {
-        return new F<Rand, A>() {
-          public A f(final Rand r) {
-            return a;
-          }
-        };
-      }
-    });
+    return new Gen<A>(i -> r -> a);
   }
 
   /**
@@ -410,15 +374,7 @@ public static Gen<Integer> choose(final int from, final int to) {
   public static Gen<Double> choose(final double from, final double to) {
     final double f = min(from, to);
     final double t = max(from, to);
-    return parameterised(new F<Integer, F<Rand, Gen<Double>>>() {
-      public F<Rand, Gen<Double>> f(final Integer i) {
-        return new F<Rand, Gen<Double>>() {
-          public Gen<Double> f(final Rand r) {
-            return value(r.choose(f, t));
-          }
-        };
-      }
-    });
+    return parameterised(i -> r -> value(r.choose(f, t)));
   }
 
   /**
@@ -427,14 +383,8 @@ public Gen<Double> f(final Rand r) {
    * @return A generator that never returns a value.
    */
   public static <A> Gen<A> fail() {
-    return new Gen<A>(new F<Integer, F<Rand, A>>() {
-      public F<Rand, A> f(final Integer i) {
-        return new F<Rand, A>() {
-          public A f(final Rand r) {
-            throw error("Failing generator");
-          }
-        };
-      }
+    return new Gen<A>(i -> r -> {
+      throw error("Failing generator");
     });
   }
 
@@ -471,11 +421,7 @@ <A> Gen<A> pick(final int n, final List<P2<Integer, Gen<A>>> gs) {
 
     final F<P2<Integer, Gen<A>>, Integer> f = __1();
 
-    return choose(1, intAdditionMonoid.sumLeft(gs.map(f))).bind(new F<Integer, Gen<A>>() {
-      public Gen<A> f(final Integer i) {
-        return new Pick().pick(i, gs);
-      }
-    });
+    return choose(1, intAdditionMonoid.sumLeft(gs.map(f))).bind(i -> new Pick().pick(i, gs));
   }
 
   /**
@@ -486,11 +432,7 @@ public Gen<A> f(final Integer i) {
    * @return A new generator that uses the given pairs of frequency and value.
    */
   public static <A> Gen<A> elemFrequency(final List<P2<Integer, A>> as) {
-    return frequency(as.map(new F<P2<Integer, A>, P2<Integer, Gen<A>>>() {
-      public P2<Integer, Gen<A>> f(final P2<Integer, A> p) {
-        return p.map2(Gen::value);
-      }
-    }));
+    return frequency(as.map(p -> p.map2(Gen::value)));
   }
 
   /**
@@ -501,11 +443,7 @@ public P2<Integer, Gen<A>> f(final P2<Integer, A> p) {
    */
   @SafeVarargs
   public static <A> Gen<A> elements(final A... as) {
-    return array(as).isEmpty() ? Gen.<A>fail() : choose(0, as.length - 1).map(new F<Integer, A>() {
-      public A f(final Integer i) {
-        return as[i];
-      }
-    });
+    return array(as).isEmpty() ? Gen.<A>fail() : choose(0, as.length - 1).map(i -> as[i]);
   }
 
   /**
@@ -785,18 +723,6 @@ public static <A> Gen<List<A>> someWordOf(int maxLength, List<A> as) {
    * @return A generator for functions.
    */
   public static <A, B> Gen<F<A, B>> promote(final F<A, Gen<B>> f) {
-    return new Gen<F<A, B>>(new F<Integer, F<Rand, F<A, B>>>() {
-      public F<Rand, F<A, B>> f(final Integer i) {
-        return new F<Rand, F<A, B>>() {
-          public F<A, B> f(final Rand r) {
-            return new F<A, B>() {
-              public B f(final A a) {
-                return f.f(a).f.f(i).f(r);
-              }
-            };
-          }
-        };
-      }
-    });
+    return new Gen<F<A, B>>(i -> r -> a -> f.f(a).f.f(i).f(r));
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index d0eeb5ae..d69d0c65 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -54,15 +54,7 @@ public Result prop(final int i, final Rand r) {
    * @return A generator of results from this property.
    */
   public Gen<Result> gen() {
-    return Gen.gen(new F<Integer, F<Rand, Result>>() {
-      public F<Rand, Result> f(final Integer i) {
-        return new F<Rand, Result>() {
-          public Result f(final Rand r) {
-            return f.f(i).f(r);
-          }
-        };
-      }
-    });
+    return Gen.gen(i -> r -> f.f(i).f(r));
   }
 
   /**
@@ -72,15 +64,7 @@ public Result f(final Rand r) {
    * @return A conjunction of this property with the given property.
    */
   public Property and(final Property p) {
-    return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
-      public F<Result, Result> f(final Result res1) {
-        return new F<Result, Result>() {
-          public Result f(final Result res2) {
-            return res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res2 : res2.isProven() || res2.isUnfalsified() ? res1 : noResult();
-          }
-        };
-      }
-    }));
+    return fromGen(gen().bind(p.gen(), res1 -> res2 -> res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res2 : res2.isProven() || res2.isUnfalsified() ? res1 : noResult()));
   }
 
   /**
@@ -90,15 +74,7 @@ public Result f(final Result res2) {
    * @return A disjunction of this property with the given property.
    */
   public Property or(final Property p) {
-    return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
-      public F<Result, Result> f(final Result res1) {
-        return new F<Result, Result>() {
-          public Result f(final Result res2) {
-            return res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res1 : res2.isProven() || res2.isUnfalsified() ? res2 : noResult();
-          }
-        };
-      }
-    }));
+    return fromGen(gen().bind(p.gen(), res1 -> res2 -> res1.isException() || res1.isFalsified() ? res1 : res2.isException() || res2.isFalsified() ? res2 : res1.isProven() || res1.isUnfalsified() ? res1 : res2.isProven() || res2.isUnfalsified() ? res2 : noResult()));
   }
 
   /**
@@ -111,15 +87,7 @@ public Result f(final Result res2) {
    * @return A sequence of this property with the given property.
    */
   public Property sequence(final Property p) {
-    return fromGen(gen().bind(p.gen(), new F<Result, F<Result, Result>>() {
-      public F<Result, Result> f(final Result res1) {
-        return new F<Result, Result>() {
-          public Result f(final Result res2) {
-            return res1.isException() || res1.isProven() || res1.isUnfalsified() ? res1 : res2.isException() || res2.isProven() || res2.isUnfalsified() ? res2 : res1.isFalsified() ? res2 : res2.isFalsified() ? res1 : noResult();
-          }
-        };
-      }
-    }));
+    return fromGen(gen().bind(p.gen(), res1 -> res2 -> res1.isException() || res1.isProven() || res1.isUnfalsified() ? res1 : res2.isException() || res2.isProven() || res2.isUnfalsified() ? res2 : res1.isFalsified() ? res2 : res2.isFalsified() ? res1 : noResult()));
   }
 
   /**
@@ -351,15 +319,7 @@ public CheckResult maxSize(final Rand r, final int maxSize) {
    * @return A property that produces a result only if the given condition satisfies.
    */
   public static Property implies(final boolean b, final F0<Property> p) {
-    return b ? p.f() : new Property(new F<Integer, F<Rand, Result>>() {
-      public F<Rand, Result> f(final Integer i) {
-        return new F<Rand, Result>() {
-          public Result f(final Rand r) {
-            return noResult();
-          }
-        };
-      }
-    });
+    return b ? p.f() : new Property(i -> r -> noResult());
   }
 
     /**
@@ -395,15 +355,7 @@ public static Property prop(final F<Integer, F<Rand, Result>> f) {
    * @return A property that always has the given result.
    */
   public static Property prop(final Result r) {
-    return new Property(new F<Integer, F<Rand, Result>>() {
-      public F<Rand, Result> f(final Integer integer) {
-        return new F<Rand, Result>() {
-          public Result f(final Rand x) {
-            return r;
-          }
-        };
-      }
-    });
+    return new Property(integer -> x -> r);
   }
 
   /**
@@ -426,15 +378,7 @@ public static Property prop(final boolean b) {
    * @return A property from a generator of results.
    */
   public static Property fromGen(final Gen<Result> g) {
-    return prop(new F<Integer, F<Rand, Result>>() {
-      public F<Rand, Result> f(final Integer i) {
-        return new F<Rand, Result>() {
-          public Result f(final Rand r) {
-            return g.gen(i, r);
-          }
-        };
-      }
-    });
+    return prop(i -> r -> g.gen(i, r));
   }
 
   /**
@@ -448,56 +392,44 @@ public Result f(final Rand r) {
    *         application of its arguments.
    */
   public static <A> Property forall(final Gen<A> g, final Shrink<A> shrink, final F<A, P1<Property>> f) {
-    return prop(new F<Integer, F<Rand, Result>>() {
-      public F<Rand, Result> f(final Integer i) {
-        return new F<Rand, Result>() {
-          public Result f(final Rand r) {
-            final class Util {
-              @SuppressWarnings("IfMayBeConditional")
-              Option<P2<A, Result>> first(final Stream<A> as, final int shrinks) {
-                final Stream<Option<P2<A, Result>>> results = as.map(new F<A, Option<P2<A, Result>>>() {
-                  public Option<P2<A, Result>> f(final A a) {
-                    final Result result = exception(f.f(a)).prop(i, r);
-
-                    return result.toOption().map(new F<Result, P2<A, Result>>() {
-                      public P2<A, Result> f(final Result result) {
-                        return p(a, result.provenAsUnfalsified().addArg(arg(a, shrinks)));
-                      }
-                    });
-                  }
-                });
-
-                if (results.isEmpty())
-                  return none();
-                else return results.find(this::failed).orSome(results::head);
-              }
-
-              public boolean failed(final Option<P2<A, Result>> o) {
-                return o.isSome() && o.some()._2().failed();
-              }
-            }
-
-            final Util u = new Util();
-
-            Option<P2<A, Result>> x = u.first(Stream.single(g.gen(i, r)), 0);
-            final F<P2<A, Result>, Result> __2 = __2();
-            if (u.failed(x)) {
-              Option<Result> or;
-              int shrinks = 0;
-
-              do {
-                shrinks++;
-                or = x.map(__2);
-                x = u.first(shrink.shrink(x.some()._1()), shrinks);
-              }
-              while (u.failed(x));
-
-              return noResult(or);
-            } else
-              return noResult(x.map(__2));
-          }
-        };
+    return prop(i -> r -> {
+      final class Util {
+        @SuppressWarnings("IfMayBeConditional")
+        Option<P2<A, Result>> first(final Stream<A> as, final int shrinks) {
+          final Stream<Option<P2<A, Result>>> results = as.map(a -> {
+            final Result result = exception(f.f(a)).prop(i, r);
+
+            return result.toOption().map(result1 -> p(a, result1.provenAsUnfalsified().addArg(arg(a, shrinks))));
+          });
+
+          if (results.isEmpty())
+            return none();
+          else return results.find(this::failed).orSome(results::head);
+        }
+
+        public boolean failed(final Option<P2<A, Result>> o) {
+          return o.isSome() && o.some()._2().failed();
+        }
       }
+
+      final Util u = new Util();
+
+      Option<P2<A, Result>> x = u.first(Stream.single(g.gen(i, r)), 0);
+      final F<P2<A, Result>, Result> __2 = __2();
+      if (u.failed(x)) {
+        Option<Result> or;
+        int shrinks = 0;
+
+        do {
+          shrinks++;
+          or = x.map(__2);
+          x = u.first(shrink.shrink(x.some()._1()), shrinks);
+        }
+        while (u.failed(x));
+
+        return noResult(or);
+      } else
+        return noResult(x.map(__2));
     });
   }
 
@@ -569,14 +501,10 @@ public static <A> Property property(final Arbitrary<A> aa, final F<A, Property>
    *         application of its arguments.
    */
   public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, P1<Property>>> f) {
-    return property(aa, sa, new F<A, Property>() {
-      public Property f(final A a) {
-        return propertyP(ab, sb, new F<B, P1<Property>>() {
-          public P1<Property> f(final B b) {
-            return f.f(a).f(b);
-          }
-        });
-      }
+    return property(aa, sa, a -> {
+      return propertyP(ab, sb, b -> {
+        return f.f(a).f(b);
+      });
     });
   }
 
@@ -607,15 +535,7 @@ public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B>
    *         application of its arguments.
    */
   public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, P1<Property>>> f) {
-    return property(aa, new F<A, Property>() {
-      public Property f(final A a) {
-        return propertyP(ab, new F<B, P1<Property>>() {
-          public P1<Property> f(final B b) {
-            return f.f(a).f(b);
-          }
-        });
-      }
-    });
+    return property(aa, a -> propertyP(ab, b -> f.f(a).f(b)));
   }
 
   /**
@@ -713,19 +633,9 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
                                             final Shrink<B> sb,
                                             final Shrink<C> sc,
                                             final F<A, F<B, F<C, Property>>> f) {
-    return property(aa, ab, sa, sb, new F<A, F<B, Property>>() {
-      public F<B, Property> f(final A a) {
-        return new F<B, Property>() {
-          public Property f(final B b) {
-            return property(ac, sc, new F<C, Property>() {
-              public Property f(final C c) {
-                return f.f(a).f(b).f(c);
-              }
-            });
-          }
-        };
-      }
-    });
+    return property(aa, ab, sa, sb, a -> b -> property(ac, sc, c -> {
+      return f.f(a).f(b).f(c);
+    }));
   }
 
   /**
@@ -743,19 +653,7 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
                                             final Arbitrary<B> ab,
                                             final Arbitrary<C> ac,
                                             final F<A, F<B, F<C, Property>>> f) {
-    return property(aa, ab, new F<A, F<B, Property>>() {
-      public F<B, Property> f(final A a) {
-        return new F<B, Property>() {
-          public Property f(final B b) {
-            return property(ac, new F<C, Property>() {
-              public Property f(final C c) {
-                return f.f(a).f(b).f(c);
-              }
-            });
-          }
-        };
-      }
-    });
+    return property(aa, ab, a -> b -> property(ac, c -> f.f(a).f(b).f(c)));
   }
 
   /**
@@ -825,23 +723,9 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
                                                final Shrink<C> sc,
                                                final Shrink<D> sd,
                                                final F<A, F<B, F<C, F<D, Property>>>> f) {
-    return property(aa, ab, ac, sa, sb, sc, new F<A, F<B, F<C, Property>>>() {
-      public F<B, F<C, Property>> f(final A a) {
-        return new F<B, F<C, Property>>() {
-          public F<C, Property> f(final B b) {
-            return new F<C, Property>() {
-              public Property f(final C c) {
-                return property(ad, sd, new F<D, Property>() {
-                  public Property f(final D d) {
-                    return f.f(a).f(b).f(c).f(d);
-                  }
-                });
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, sa, sb, sc, a -> b -> c -> property(ad, sd, d -> {
+      return f.f(a).f(b).f(c).f(d);
+    }));
   }
 
   /**
@@ -861,23 +745,7 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
                                                final Arbitrary<C> ac,
                                                final Arbitrary<D> ad,
                                                final F<A, F<B, F<C, F<D, Property>>>> f) {
-    return property(aa, ab, ac, new F<A, F<B, F<C, Property>>>() {
-      public F<B, F<C, Property>> f(final A a) {
-        return new F<B, F<C, Property>>() {
-          public F<C, Property> f(final B b) {
-            return new F<C, Property>() {
-              public Property f(final C c) {
-                return property(ad, new F<D, Property>() {
-                  public Property f(final D d) {
-                    return f.f(a).f(b).f(c).f(d);
-                  }
-                });
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, a -> b -> c -> property(ad, d -> f.f(a).f(b).f(c).f(d)));
   }
 
   /**
@@ -957,27 +825,9 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
                                                   final Shrink<D> sd,
                                                   final Shrink<E> se,
                                                   final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
-    return property(aa, ab, ac, ad, sa, sb, sc, sd, new F<A, F<B, F<C, F<D, Property>>>>() {
-      public F<B, F<C, F<D, Property>>> f(final A a) {
-        return new F<B, F<C, F<D, Property>>>() {
-          public F<C, F<D, Property>> f(final B b) {
-            return new F<C, F<D, Property>>() {
-              public F<D, Property> f(final C c) {
-                return new F<D, Property>() {
-                  public Property f(final D d) {
-                    return property(ae, se, new F<E, Property>() {
-                      public Property f(final E e) {
-                        return f.f(a).f(b).f(c).f(d).f(e);
-                      }
-                    });
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, sa, sb, sc, sd, a -> b -> c -> d -> property(ae, se, e -> {
+      return f.f(a).f(b).f(c).f(d).f(e);
+    }));
   }
 
   /**
@@ -999,27 +849,7 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
                                                   final Arbitrary<D> ad,
                                                   final Arbitrary<E> ae,
                                                   final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
-    return property(aa, ab, ac, ad, new F<A, F<B, F<C, F<D, Property>>>>() {
-      public F<B, F<C, F<D, Property>>> f(final A a) {
-        return new F<B, F<C, F<D, Property>>>() {
-          public F<C, F<D, Property>> f(final B b) {
-            return new F<C, F<D, Property>>() {
-              public F<D, Property> f(final C c) {
-                return new F<D, Property>() {
-                  public Property f(final D d) {
-                    return property(ae, new F<E, Property>() {
-                      public Property f(final E e) {
-                        return f.f(a).f(b).f(c).f(d).f(e);
-                      }
-                    });
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, a -> b -> c -> d -> property(ae, e -> f.f(a).f(b).f(c).f(d).f(e)));
   }
 
   /**
@@ -1109,31 +939,9 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
                                                       final Shrink<E> se,
                                                       final Shrink<F$> sf,
                                                       final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, new F<A, F<B, F<C, F<D, F<E, Property>>>>>() {
-      public F<B, F<C, F<D, F<E, Property>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, Property>>>>() {
-          public F<C, F<D, F<E, Property>>> f(final B b) {
-            return new F<C, F<D, F<E, Property>>>() {
-              public F<D, F<E, Property>> f(final C c) {
-                return new F<D, F<E, Property>>() {
-                  public F<E, Property> f(final D d) {
-                    return new F<E, Property>() {
-                      public Property f(final E e) {
-                        return property(af, sf, new F<F$, Property>() {
-                          public Property f(final F$ f$) {
-                            return f.f(a).f(b).f(c).f(d).f(e).f(f$);
-                          }
-                        });
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, a -> b -> c -> d -> e -> property(af, sf, f$ -> {
+      return f.f(a).f(b).f(c).f(d).f(e).f(f$);
+    }));
   }
 
   /**
@@ -1157,31 +965,7 @@ public Property f(final F$ f$) {
                                                       final Arbitrary<E> ae,
                                                       final Arbitrary<F$> af,
                                                       final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, new F<A, F<B, F<C, F<D, F<E, Property>>>>>() {
-      public F<B, F<C, F<D, F<E, Property>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, Property>>>>() {
-          public F<C, F<D, F<E, Property>>> f(final B b) {
-            return new F<C, F<D, F<E, Property>>>() {
-              public F<D, F<E, Property>> f(final C c) {
-                return new F<D, F<E, Property>>() {
-                  public F<E, Property> f(final D d) {
-                    return new F<E, Property>() {
-                      public Property f(final E e) {
-                        return property(af, new F<F$, Property>() {
-                          public Property f(final F$ f$) {
-                            return f.f(a).f(b).f(c).f(d).f(e).f(f$);
-                          }
-                        });
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, a -> b -> c -> d -> e -> property(af, f$ -> f.f(a).f(b).f(c).f(d).f(e).f(f$)));
   }
 
   /**
@@ -1281,35 +1065,9 @@ public Property f(final F$ f$) {
                                                          final Shrink<F$> sf,
                                                          final Shrink<G> sg,
                                                          final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, new F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>>() {
-      public F<B, F<C, F<D, F<E, F<F$, Property>>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, F<F$, Property>>>>>() {
-          public F<C, F<D, F<E, F<F$, Property>>>> f(final B b) {
-            return new F<C, F<D, F<E, F<F$, Property>>>>() {
-              public F<D, F<E, F<F$, Property>>> f(final C c) {
-                return new F<D, F<E, F<F$, Property>>>() {
-                  public F<E, F<F$, Property>> f(final D d) {
-                    return new F<E, F<F$, Property>>() {
-                      public F<F$, Property> f(final E e) {
-                        return new F<F$, Property>() {
-                          public Property f(final F$ f$) {
-                            return property(ag, sg, new F<G, Property>() {
-                              public Property f(final G g) {
-                                return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
-                              }
-                            });
-                          }
-                        };
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, a -> b -> c -> d -> e -> f$ -> property(ag, sg, g -> {
+      return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
+    }));
   }
 
   /**
@@ -1335,35 +1093,7 @@ public Property f(final G g) {
                                                          final Arbitrary<F$> af,
                                                          final Arbitrary<G> ag,
                                                          final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, new F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>>() {
-      public F<B, F<C, F<D, F<E, F<F$, Property>>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, F<F$, Property>>>>>() {
-          public F<C, F<D, F<E, F<F$, Property>>>> f(final B b) {
-            return new F<C, F<D, F<E, F<F$, Property>>>>() {
-              public F<D, F<E, F<F$, Property>>> f(final C c) {
-                return new F<D, F<E, F<F$, Property>>>() {
-                  public F<E, F<F$, Property>> f(final D d) {
-                    return new F<E, F<F$, Property>>() {
-                      public F<F$, Property> f(final E e) {
-                        return new F<F$, Property>() {
-                          public Property f(final F$ f$) {
-                            return property(ag, new F<G, Property>() {
-                              public Property f(final G g) {
-                                return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
-                              }
-                            });
-                          }
-                        };
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, af, a -> b -> c -> d -> e -> f$ -> property(ag, g -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g)));
   }
 
   /**
@@ -1473,39 +1203,9 @@ public Property f(final G g) {
                                                             final Shrink<G> sg,
                                                             final Shrink<H> sh,
                                                             final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>>() {
-      public F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>() {
-          public F<C, F<D, F<E, F<F$, F<G, Property>>>>> f(final B b) {
-            return new F<C, F<D, F<E, F<F$, F<G, Property>>>>>() {
-              public F<D, F<E, F<F$, F<G, Property>>>> f(final C c) {
-                return new F<D, F<E, F<F$, F<G, Property>>>>() {
-                  public F<E, F<F$, F<G, Property>>> f(final D d) {
-                    return new F<E, F<F$, F<G, Property>>>() {
-                      public F<F$, F<G, Property>> f(final E e) {
-                        return new F<F$, F<G, Property>>() {
-                          public F<G, Property> f(final F$ f$) {
-                            return new F<G, Property>() {
-                              public Property f(final G g) {
-                                return property(ah, sh, new F<H, Property>() {
-                                  public Property f(final H h) {
-                                    return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
-                                  }
-                                });
-                              }
-                            };
-                          }
-                        };
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, a -> b -> c -> d -> e -> f$ -> g -> property(ah, sh, h -> {
+      return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
+    }));
   }
 
   /**
@@ -1533,39 +1233,7 @@ public Property f(final H h) {
                                                             final Arbitrary<G> ag,
                                                             final Arbitrary<H> ah,
                                                             final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, ag, new F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>>() {
-      public F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>> f(final A a) {
-        return new F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>() {
-          public F<C, F<D, F<E, F<F$, F<G, Property>>>>> f(final B b) {
-            return new F<C, F<D, F<E, F<F$, F<G, Property>>>>>() {
-              public F<D, F<E, F<F$, F<G, Property>>>> f(final C c) {
-                return new F<D, F<E, F<F$, F<G, Property>>>>() {
-                  public F<E, F<F$, F<G, Property>>> f(final D d) {
-                    return new F<E, F<F$, F<G, Property>>>() {
-                      public F<F$, F<G, Property>> f(final E e) {
-                        return new F<F$, F<G, Property>>() {
-                          public F<G, Property> f(final F$ f$) {
-                            return new F<G, Property>() {
-                              public Property f(final G g) {
-                                return property(ah, new F<H, Property>() {
-                                  public Property f(final H h) {
-                                    return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
-                                  }
-                                });
-                              }
-                            };
-                          }
-                        };
-                      }
-                    };
-                  }
-                };
-              }
-            };
-          }
-        };
-      }
-    });
+    return property(aa, ab, ac, ad, ae, af, ag, a -> b -> c -> d -> e -> f$ -> g -> property(ah, h -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h)));
   }
 
   /**
@@ -1652,15 +1320,7 @@ public static Property exception(final F0<Property> p) {
     try {
       return p.f();
     } catch (final Throwable t) {
-      return new Property(new F<Integer, F<Rand, Result>>() {
-        public F<Rand, Result> f(final Integer i) {
-          return new F<Rand, Result>() {
-            public Result f(final Rand r) {
-              return Result.exception(List.<Arg<?>>nil(), t);
-            }
-          };
-        }
-      });
+      return new Property(i -> r -> Result.exception(List.<Arg<?>>nil(), t));
     }
   }
 
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index a4994bcb..f4da2459 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -80,11 +80,7 @@ public static <T> List<P2<String, CheckResult>> check(final List<java.lang.Class
    * @return The results and names of checking the properties on the given classes.
    */
   public static <T> List<P2<String, CheckResult>> check(final List<java.lang.Class<T>> c, final Rand r, final String... categories) {
-    return join(c.map(new F<java.lang.Class<T>, List<P2<String, CheckResult>>>() {
-      public List<P2<String, CheckResult>> f(final java.lang.Class<T> c) {
-        return check(c, r, categories);
-      }
-    }));
+    return join(c.map(c1 -> check(c1, r, categories)));
   }
 
   /**
@@ -142,18 +138,12 @@ public static <T> List<P2<String, CheckResult>> check(final java.lang.Class<T> c
    * @return The results of checking the properties on the given class.
    */
   public static <T> List<P2<String, CheckResult>> check(final java.lang.Class<T> c, final Rand r, final String... categories) {
-    return join(clas(c).inheritance().map(new F<Class<? super T>, List<P3<Property, String, Option<CheckParams>>>>() {
-      public List<P3<Property, String, Option<CheckParams>>> f(final Class<? super T> c) {
-        return properties(c.clas(), categories);
-      }
-    })).map(new F<P3<Property, String, Option<CheckParams>>, P2<String, CheckResult>>() {
-      public P2<String, CheckResult> f(final P3<Property, String, Option<CheckParams>> p) {
-        if(p._3().isSome()) {
-          final CheckParams ps = p._3().some();
-          return p(p._2(), p._1().check(r, ps.minSuccessful(), ps.maxDiscarded(), ps.minSize(), ps.maxSize()));
-        } else
-          return p(p._2(), p._1().check(r));
-      }
+    return join(clas(c).inheritance().map(c1 -> properties(c1.clas(), categories))).map(p -> {
+      if(p._3().isSome()) {
+        final CheckParams ps = p._3().some();
+        return p(p._2(), p._1().check(r, ps.minSuccessful(), ps.maxDiscarded(), ps.minSize(), ps.maxSize()));
+      } else
+        return p(p._2(), p._1().check(r));
     });
   }
 
@@ -187,68 +177,62 @@ public static <T> List<P2<String, CheckResult>> check(final java.lang.Class<T> c
    */
   public static <U, T extends U> List<P3<Property, String, Option<CheckParams>>> properties(final java.lang.Class<T> c, final String... categories) {
     //noinspection ClassEscapesDefinedScope
-    final Array<P3<Property, String, Option<CheckParams>>> propFields = properties(array(c.getDeclaredFields()).map(new F<Field, PropertyMember>() {
-      public PropertyMember f(final Field f) {
-        return new PropertyMember() {
-          public java.lang.Class<?> type() {
-            return f.getType();
-          }
-
-          public AnnotatedElement element() {
-            return f;
-          }
-
-          public String name() {
-            return f.getName();
-          }
-
-          public int modifiers() {
-            return f.getModifiers();
-          }
-
-          public <X> Property invoke(final X x) throws IllegalAccessException {
-            f.setAccessible(true);
-            return (Property)f.get(x);
-          }
-
-          public boolean isProperty() {
-            return true;
-          }
-        };
+    final Array<P3<Property, String, Option<CheckParams>>> propFields = properties(array(c.getDeclaredFields()).map((F<Field, PropertyMember>) f -> new PropertyMember() {
+      public java.lang.Class<?> type() {
+        return f.getType();
+      }
+
+      public AnnotatedElement element() {
+        return f;
+      }
+
+      public String name() {
+        return f.getName();
+      }
+
+      public int modifiers() {
+        return f.getModifiers();
+      }
+
+      public <X> Property invoke(final X x) throws IllegalAccessException {
+        f.setAccessible(true);
+        return (Property)f.get(x);
+      }
+
+      public boolean isProperty() {
+        return true;
       }
     }), c, categories);
 
     //noinspection ClassEscapesDefinedScope
-    final Array<P3<Property, String, Option<CheckParams>>> propMethods = properties(array(c.getDeclaredMethods()).map(new F<Method, PropertyMember>() {
-      public PropertyMember f(final Method m) {
-        //noinspection ProhibitedExceptionDeclared
-        return new PropertyMember() {
-          public java.lang.Class<?> type() {
-            return m.getReturnType();
-          }
-
-          public AnnotatedElement element() {
-            return m;
-          }
-
-          public String name() {
-            return m.getName();
-          }
-
-          public int modifiers() {
-            return m.getModifiers();
-          }
-
-          public <X> Property invoke(final X x) throws Exception {
-            m.setAccessible(true);
-            return (Property)m.invoke(x);
-          }
-
-          public boolean isProperty() {
-            return m.getParameterTypes().length == 0;
-          }
-        };
-      }
+    final Array<P3<Property, String, Option<CheckParams>>> propMethods = properties(array(c.getDeclaredMethods()).map((F<Method, PropertyMember>) m -> {
+      //noinspection ProhibitedExceptionDeclared
+      return new PropertyMember() {
+        public java.lang.Class<?> type() {
+          return m.getReturnType();
+        }
+
+        public AnnotatedElement element() {
+          return m;
+        }
+
+        public String name() {
+          return m.getName();
+        }
+
+        public int modifiers() {
+          return m.getModifiers();
+        }
+
+        public <X> Property invoke(final X x) throws Exception {
+          m.setAccessible(true);
+          return (Property)m.invoke(x);
+        }
+
+        public boolean isProperty() {
+          return m.getParameterTypes().length == 0;
+        }
+      };
     }), c, categories);
 
     return propFields.append(propMethods).toList();
@@ -265,62 +249,41 @@ private interface PropertyMember {
   }
 
   private static <T> Array<P3<Property, String, Option<CheckParams>>> properties(final Array<PropertyMember> ms, final java.lang.Class<T> declaringClass, final String... categories) {
-    final Option<T> t = emptyCtor(declaringClass).map(new F<Constructor<T>, T>() {
-      @SuppressWarnings("OverlyBroadCatchBlock")
-      public T f(final Constructor<T> ctor) {
-        try {
-          ctor.setAccessible(true);
-          return ctor.newInstance();
-        } catch(Exception e) {
-          throw new Error(e.getMessage(), e);
-        }
+    final Option<T> t = emptyCtor(declaringClass).map(ctor -> {
+      try {
+        ctor.setAccessible(true);
+        return ctor.newInstance();
+      } catch(Exception e) {
+        throw new Error(e.getMessage(), e);
       }
     });
 
-    final F<AnnotatedElement, F<String, Boolean>> p = new F<AnnotatedElement, F<String, Boolean>>() {
-      public F<String, Boolean> f(final AnnotatedElement e) {
-        return new F<String, Boolean>() {
-          public Boolean f(final String s) {
-            final F<Category, Boolean> p = new F<Category, Boolean>() {
-              public Boolean f(final Category c) {
-                return array(c.value()).exists(new F<String, Boolean>() {
-                  public Boolean f(final String cs) {
-                    return cs.equals(s);
-                  }
-                });
-              }
-            };
-
-            @SuppressWarnings("unchecked")
-            final List<Boolean> bss = somes(list(fromNull(e.getAnnotation(Category.class)).map(p),
-              fromNull(declaringClass.getAnnotation(Category.class)).map(p)));
-            return bss.exists(Function.<Boolean>identity());
-          }
-        };
-      }
+    final F<AnnotatedElement, F<String, Boolean>> p = e -> s -> {
+      final F<Category, Boolean> p1 = c -> array(c.value()).exists(cs -> cs.equals(s));
+
+      @SuppressWarnings("unchecked")
+      final List<Boolean> bss = somes(list(fromNull(e.getAnnotation(Category.class)).map(p1),
+        fromNull(declaringClass.getAnnotation(Category.class)).map(p1)));
+      return bss.exists(Function.<Boolean>identity());
     };
 
     final F<Name, String> nameS = Name::value;
 
-    return ms.filter(new F<PropertyMember, Boolean>() {
-      public Boolean f(final PropertyMember m) {
-        //noinspection ObjectEquality
-        return m.isProperty() &&
-            m.type() == Property.class &&
-            !m.element().isAnnotationPresent(NoCheck.class) &&
-            !declaringClass.isAnnotationPresent(NoCheck.class) &&
-            (categories.length == 0 || array(categories).exists(p.f(m.element()))) &&
-            (t.isSome() || isStatic(m.modifiers()));
-      }
-    }).map(new F<PropertyMember, P3<Property, String, Option<CheckParams>>>() {
-      public P3<Property, String, Option<CheckParams>> f(final PropertyMember m) {
-        try {
-          final Option<CheckParams> params = fromNull(m.element().getAnnotation(CheckParams.class)).orElse(fromNull(declaringClass.getAnnotation(CheckParams.class)));
-          final String name = fromNull(m.element().getAnnotation(Name.class)).map(nameS).orSome(m.name());
-          return p(m.invoke(t.orSome(P.<T>p(null))), name, params);
-        } catch(Exception e) {
-          throw new Error(e.getMessage(), e);
-        }
+    return ms.filter(m -> {
+      //noinspection ObjectEquality
+      return m.isProperty() &&
+          m.type() == Property.class &&
+          !m.element().isAnnotationPresent(NoCheck.class) &&
+          !declaringClass.isAnnotationPresent(NoCheck.class) &&
+          (categories.length == 0 || array(categories).exists(p.f(m.element()))) &&
+          (t.isSome() || isStatic(m.modifiers()));
+    }).map(m -> {
+      try {
+        final Option<CheckParams> params = fromNull(m.element().getAnnotation(CheckParams.class)).orElse(fromNull(declaringClass.getAnnotation(CheckParams.class)));
+        final String name = fromNull(m.element().getAnnotation(Name.class)).map(nameS).orSome(m.name());
+        return p(m.invoke(t.orSome(P.<T>p(null))), name, params);
+      } catch(Exception e) {
+        throw new Error(e.getMessage(), e);
       }
     });
   }
diff --git a/quickcheck/src/main/java/fj/test/reflect/Main.java b/quickcheck/src/main/java/fj/test/reflect/Main.java
index b0b5fb95..5f6f3dfc 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Main.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Main.java
@@ -36,11 +36,9 @@ public static void main(final String... args) {
       exit(441);
     } else {
       try {
-        check(forName(args[0]), array(args).toList().tail()).foreachDoEffect(new Effect1<P2<String, CheckResult>>() {
-            public void f(final P2<String, CheckResult> r) {
-                summary.print(r._2());
-                out.println(" (" + r._1() + ')');
-            }
+        check(forName(args[0]), array(args).toList().tail()).foreachDoEffect(r -> {
+            summary.print(r._2());
+            out.println(" (" + r._1() + ')');
         });
       } catch(ClassNotFoundException e) {
         e.printStackTrace();

From 4b053ca403df1469db25c8d17cf7049460516c0a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 5 Mar 2016 23:16:42 +0100
Subject: [PATCH 045/336] Make use of type inference

---
 core/src/main/java/fj/Class.java              |   4 +-
 core/src/main/java/fj/Equal.java              |  24 +-
 core/src/main/java/fj/F1Functions.java        |  32 +-
 core/src/main/java/fj/F1W.java                |   2 +-
 core/src/main/java/fj/Function.java           |   4 +-
 core/src/main/java/fj/Hash.java               |  22 +-
 core/src/main/java/fj/LcgRng.java             |   2 +-
 core/src/main/java/fj/Monoid.java             |  22 +-
 core/src/main/java/fj/Ord.java                |  12 +-
 core/src/main/java/fj/P1.java                 |  10 +-
 core/src/main/java/fj/P2.java                 |   4 +-
 core/src/main/java/fj/P3.java                 |   2 +-
 core/src/main/java/fj/P4.java                 |   2 +-
 core/src/main/java/fj/P5.java                 |   2 +-
 core/src/main/java/fj/P6.java                 |  14 +-
 core/src/main/java/fj/P7.java                 |  16 +-
 core/src/main/java/fj/P8.java                 |  18 +-
 core/src/main/java/fj/Semigroup.java          |   4 +-
 core/src/main/java/fj/Show.java               |  18 +-
 core/src/main/java/fj/control/Trampoline.java |  10 +-
 core/src/main/java/fj/control/db/DB.java      |   2 +-
 .../main/java/fj/control/parallel/Actor.java  |   8 +-
 .../java/fj/control/parallel/Callables.java   |   5 +-
 .../java/fj/control/parallel/ParModule.java   |  30 +-
 .../java/fj/control/parallel/Promise.java     |  18 +-
 .../java/fj/control/parallel/Strategy.java    |  20 +-
 core/src/main/java/fj/data/$.java             |   2 +-
 core/src/main/java/fj/data/Array.java         |  44 +--
 core/src/main/java/fj/data/DList.java         |   4 +-
 core/src/main/java/fj/data/Either.java        |  88 +++---
 core/src/main/java/fj/data/Enumerator.java    |  90 +++---
 core/src/main/java/fj/data/HashMap.java       |  40 +--
 core/src/main/java/fj/data/HashSet.java       |  10 +-
 core/src/main/java/fj/data/IOFunctions.java   |  32 +-
 core/src/main/java/fj/data/IterableW.java     |   6 +-
 core/src/main/java/fj/data/Iteratee.java      |  16 +-
 core/src/main/java/fj/data/Java.java          | 290 +++++++++---------
 core/src/main/java/fj/data/LazyString.java    |   2 +-
 core/src/main/java/fj/data/List.java          |  78 ++---
 core/src/main/java/fj/data/Natural.java       |   2 +-
 core/src/main/java/fj/data/NonEmptyList.java  |  12 +-
 core/src/main/java/fj/data/Option.java        |  48 +--
 core/src/main/java/fj/data/Reader.java        |   2 +-
 core/src/main/java/fj/data/Seq.java           |  16 +-
 core/src/main/java/fj/data/Set.java           |  38 +--
 core/src/main/java/fj/data/State.java         |   6 +-
 core/src/main/java/fj/data/Stream.java        |  60 ++--
 core/src/main/java/fj/data/Tree.java          |  20 +-
 core/src/main/java/fj/data/TreeMap.java       |  44 +--
 core/src/main/java/fj/data/TreeZipper.java    |  54 ++--
 core/src/main/java/fj/data/Validation.java    |  38 +--
 core/src/main/java/fj/data/Writer.java        |   4 +-
 core/src/main/java/fj/data/Zipper.java        |  44 +--
 .../main/java/fj/data/fingertrees/Deep.java   |  40 +--
 .../main/java/fj/data/fingertrees/Digit.java  |  30 +-
 .../main/java/fj/data/fingertrees/Empty.java  |   4 +-
 .../java/fj/data/fingertrees/FingerTree.java  |   6 +-
 .../java/fj/data/fingertrees/MakeTree.java    |  22 +-
 .../java/fj/data/fingertrees/Measured.java    |   6 +-
 .../main/java/fj/data/fingertrees/Node.java   |   4 +-
 .../main/java/fj/data/fingertrees/Node2.java  |   2 +-
 .../main/java/fj/data/fingertrees/Node3.java  |   2 +-
 .../main/java/fj/data/fingertrees/Single.java |   6 +-
 core/src/main/java/fj/data/hlist/HList.java   |  10 +-
 core/src/main/java/fj/data/optic/Fold.java    |   2 +-
 .../src/main/java/fj/data/optic/Optional.java |   4 +-
 .../main/java/fj/data/optic/POptional.java    |   2 +-
 core/src/main/java/fj/data/optic/Prism.java   |   2 +-
 core/src/main/java/fj/data/vector/V2.java     |   2 +-
 core/src/main/java/fj/data/vector/V3.java     |   8 +-
 core/src/main/java/fj/data/vector/V4.java     |  34 +-
 core/src/main/java/fj/data/vector/V5.java     |  42 +--
 core/src/main/java/fj/data/vector/V6.java     |  50 +--
 core/src/main/java/fj/data/vector/V7.java     |  58 ++--
 core/src/main/java/fj/data/vector/V8.java     |  54 ++--
 core/src/main/java/fj/function/Visitor.java   |   6 +-
 core/src/main/java/fj/parser/Parser.java      |  26 +-
 core/src/main/java/fj/parser/Result.java      |   2 +-
 demo/src/main/java/fj/demo/ChequeWrite.java   |  10 +-
 .../main/java/fj/demo/Comonad_example.java    |   4 +-
 demo/src/main/java/fj/demo/Option_bind.java   |   6 +-
 .../fj/demo/StateDemo_VendingMachine.java     |   2 +-
 .../main/java/fj/demo/concurrent/Fibs.java    |   2 +-
 .../java/fj/demo/concurrent/MapReduce.java    |   2 +-
 .../java/fj/demo/concurrent/WordCount.java    |  20 +-
 .../java/fj/demo/test/JavaLinkedList.java     |   2 +-
 .../java/fj/demo/test/ListFunctorLaws.java    |   2 +-
 .../fj/demo/test/OptionMonadFunctorLaw.java   |   2 +-
 .../src/main/java/fj/test/Arbitrary.java      | 130 ++++----
 quickcheck/src/main/java/fj/test/Arg.java     |   2 +-
 .../src/main/java/fj/test/CheckResult.java    |  10 +-
 .../src/main/java/fj/test/Coarbitrary.java    |  22 +-
 quickcheck/src/main/java/fj/test/Gen.java     |  24 +-
 .../src/main/java/fj/test/Property.java       |  14 +-
 quickcheck/src/main/java/fj/test/Rand.java    |   4 +-
 quickcheck/src/main/java/fj/test/Result.java  |   8 +-
 quickcheck/src/main/java/fj/test/Shrink.java  |  56 ++--
 quickcheck/src/main/java/fj/test/Variant.java |   2 +-
 .../src/main/java/fj/test/reflect/Check.java  |   4 +-
 99 files changed, 1074 insertions(+), 1075 deletions(-)

diff --git a/core/src/main/java/fj/Class.java b/core/src/main/java/fj/Class.java
index d34aedb7..56222de1 100644
--- a/core/src/main/java/fj/Class.java
+++ b/core/src/main/java/fj/Class.java
@@ -101,7 +101,7 @@ public static Tree<Type> typeParameterTree(final Type t) {
       }
       types = Tree.node(pt.getRawType(), typeArgs);
     } else {
-      types = Tree.node(t, List.<Tree<Type>>nil());
+      types = Tree.node(t, List.nil());
     }
     return types;
   }
@@ -122,6 +122,6 @@ public java.lang.Class<T> clas() {
    * @return A class from the given argument.
    */
   public static <T> Class<T> clas(final java.lang.Class<T> c) {
-    return new Class<T>(c);
+    return new Class<>(c);
   }
 }
diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index f503d096..2282b04e 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -75,7 +75,7 @@ public F<A, Boolean> eq(final A a) {
    * @return A new equal.
    */
   public <B> Equal<B> contramap(final F<B, A> f) {
-    return equal(F1Functions.o(F1Functions.o(F1Functions.<B, A, Boolean>andThen(f), this.f), f));
+    return equal(F1Functions.o(F1Functions.o(F1Functions.andThen(f), this.f), f));
   }
 
   /**
@@ -85,7 +85,7 @@ public <B> Equal<B> contramap(final F<B, A> f) {
    * @return An equal instance from the given function.
    */
   public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
-    return new Equal<A>(f);
+    return new Equal<>(f);
   }
 
   /**
@@ -202,7 +202,7 @@ public static <A, B> Equal<Either<A, B>> eitherEqual(final Equal<A> ea, final Eq
    * @return An equal instance for the {@link Validation} type.
    */
   public static <A, B> Equal<Validation<A, B>> validationEqual(final Equal<A> ea, final Equal<B> eb) {
-    return eitherEqual(ea, eb).contramap(Validation.<A, B>either());
+    return eitherEqual(ea, eb).contramap(Validation.either());
   }
 
   /**
@@ -235,7 +235,7 @@ public static <A> Equal<List<A>> listEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link NonEmptyList} type.
    */
   public static <A> Equal<NonEmptyList<A>> nonEmptyListEqual(final Equal<A> ea) {
-    return listEqual(ea).contramap(NonEmptyList.<A>toList_());
+    return listEqual(ea).contramap(NonEmptyList.toList_());
   }
 
   /**
@@ -302,7 +302,7 @@ public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link Tree} type.
    */
   public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
-    return Equal.<Tree<A>>equal(curry((t1, t2) -> ea.eq(t1.root(), t2.root()) && p1Equal(streamEqual(Equal.<A>treeEqual(ea))).eq(t2.subForest(), t1.subForest())));
+    return Equal.equal(curry((t1, t2) -> ea.eq(t1.root(), t2.root()) && p1Equal(streamEqual(Equal.treeEqual(ea))).eq(t2.subForest(), t1.subForest())));
   }
 
   /**
@@ -443,7 +443,7 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
    * @return An equal instance for a vector-2.
    */
   public static <A> Equal<V2<A>> v2Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V2.<A>toStream_());
+    return streamEqual(ea).contramap(V2.toStream_());
   }
 
   /**
@@ -453,7 +453,7 @@ public static <A> Equal<V2<A>> v2Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-3.
    */
   public static <A> Equal<V3<A>> v3Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V3.<A>toStream_());
+    return streamEqual(ea).contramap(V3.toStream_());
   }
 
   /**
@@ -463,7 +463,7 @@ public static <A> Equal<V3<A>> v3Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-4.
    */
   public static <A> Equal<V4<A>> v4Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V4.<A>toStream_());
+    return streamEqual(ea).contramap(V4.toStream_());
   }
 
   /**
@@ -473,7 +473,7 @@ public static <A> Equal<V4<A>> v4Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-5.
    */
   public static <A> Equal<V5<A>> v5Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V5.<A>toStream_());
+    return streamEqual(ea).contramap(V5.toStream_());
   }
 
   /**
@@ -483,7 +483,7 @@ public static <A> Equal<V5<A>> v5Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-6.
    */
   public static <A> Equal<V6<A>> v6Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V6.<A>toStream_());
+    return streamEqual(ea).contramap(V6.toStream_());
   }
 
   /**
@@ -493,7 +493,7 @@ public static <A> Equal<V6<A>> v6Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-7.
    */
   public static <A> Equal<V7<A>> v7Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V7.<A>toStream_());
+    return streamEqual(ea).contramap(V7.toStream_());
   }
 
   /**
@@ -503,7 +503,7 @@ public static <A> Equal<V7<A>> v7Equal(final Equal<A> ea) {
    * @return An equal instance for a vector-8.
    */
   public static <A> Equal<V8<A>> v8Equal(final Equal<A> ea) {
-    return streamEqual(ea).contramap(V8.<A>toStream_());
+    return streamEqual(ea).contramap(V8.toStream_());
   }
 
   /**
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 3faf1b5e..7b97675a 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -261,7 +261,7 @@ public static <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
      */
     @SuppressWarnings("unchecked")
     public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
-        return o(Either.<B, C>left_(), f);
+        return o(Either.left_(), f);
     }
 
     /**
@@ -272,7 +272,7 @@ public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
      */
     @SuppressWarnings("unchecked")
     public static <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
-        return o(Either.<C, B>right_(), f);
+        return o(Either.right_(), f);
     }
 
     /**
@@ -330,7 +330,7 @@ public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
      */
     @SuppressWarnings("unchecked")
     public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
-        return o(IterableW.<A, B>map().f(f), IterableW.<A, Iterable<A>>wrap());
+        return o(IterableW.<A, B>map().f(f), IterableW.wrap());
     }
 
     /**
@@ -340,7 +340,7 @@ public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
      */
     @SuppressWarnings("unchecked")
     public static <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
-        return o(NonEmptyList.<B>nel(), f);
+        return o(NonEmptyList.nel(), f);
     }
 
     /**
@@ -408,7 +408,7 @@ public static <A, B> F<Tree<A>, B> foldMapTree(final F<A, B> f, final Monoid<B>
      * @return This function promoted to return its value in a TreeZipper.
      */
     public static <A, B> F<A, TreeZipper<B>> treeZipperK(final F<A, B> f) {
-        return andThen(treeK(f), TreeZipper.<B>fromTree());
+        return andThen(treeK(f), TreeZipper.fromTree());
     }
 
     /**
@@ -560,7 +560,7 @@ public static <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
      * @return A new SynchronousQueue with this function applied to each element.
      */
     public static <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final SynchronousQueue<A> as) {
-        final SynchronousQueue<B> bs = new SynchronousQueue<B>();
+        final SynchronousQueue<B> bs = new SynchronousQueue<>();
         bs.addAll(iterableStream(as).map(f).toCollection());
         return bs;
     }
@@ -573,7 +573,7 @@ public static <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final Synchronous
      * @return A new PriorityBlockingQueue with this function applied to each element.
      */
     public static <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final PriorityBlockingQueue<A> as) {
-        return new PriorityBlockingQueue<B>(iterableStream(as).map(f).toCollection());
+        return new PriorityBlockingQueue<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -583,7 +583,7 @@ public static <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final Priori
      * @return A new LinkedBlockingQueue with this function applied to each element.
      */
     public static <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBlockingQueue<A> as) {
-        return new LinkedBlockingQueue<B>(iterableStream(as).map(f).toCollection());
+        return new LinkedBlockingQueue<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -593,7 +593,7 @@ public static <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBl
      * @return A new CopyOnWriteArraySet with this function applied to each element.
      */
     public static <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWriteArraySet<A> as) {
-        return new CopyOnWriteArraySet<B>(iterableStream(as).map(f).toCollection());
+        return new CopyOnWriteArraySet<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -603,7 +603,7 @@ public static <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWr
      * @return A new CopyOnWriteArrayList with this function applied to each element.
      */
     public static <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnWriteArrayList<A> as) {
-        return new CopyOnWriteArrayList<B>(iterableStream(as).map(f).toCollection());
+        return new CopyOnWriteArrayList<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -613,7 +613,7 @@ public static <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnW
      * @return A new ConcurrentLinkedQueue with this function applied to each element.
      */
     public static <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final ConcurrentLinkedQueue<A> as) {
-        return new ConcurrentLinkedQueue<B>(iterableStream(as).map(f).toCollection());
+        return new ConcurrentLinkedQueue<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -623,7 +623,7 @@ public static <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final Concur
      * @return A new ArrayBlockingQueue with this function applied to each element.
      */
     public static <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBlockingQueue<A> as) {
-        final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<B>(as.size());
+        final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<>(as.size());
         bs.addAll(iterableStream(as).map(f).toCollection());
         return bs;
     }
@@ -636,7 +636,7 @@ public static <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBloc
      * @return A new TreeSet with this function applied to each element.
      */
     public static <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
-        return new TreeSet<B>(iterableStream(as).map(f).toCollection());
+        return new TreeSet<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -646,7 +646,7 @@ public static <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
      * @return A new PriorityQueue with this function applied to each element.
      */
     public static <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<A> as) {
-        return new PriorityQueue<B>(iterableStream(as).map(f).toCollection());
+        return new PriorityQueue<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -656,7 +656,7 @@ public static <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<
      * @return A new LinkedList with this function applied to each element.
      */
     public static <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as) {
-        return new LinkedList<B>(iterableStream(as).map(f).toCollection());
+        return new LinkedList<>(iterableStream(as).map(f).toCollection());
     }
 
     /**
@@ -666,7 +666,7 @@ public static <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as)
      * @return A new ArrayList with this function applied to each element.
      */
     public static <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
-        return new ArrayList<B>(iterableStream(as).map(f).toCollection());
+        return new ArrayList<>(iterableStream(as).map(f).toCollection());
     }
 
     public static <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {
diff --git a/core/src/main/java/fj/F1W.java b/core/src/main/java/fj/F1W.java
index 7fe50e35..19a978dc 100644
--- a/core/src/main/java/fj/F1W.java
+++ b/core/src/main/java/fj/F1W.java
@@ -682,6 +682,6 @@ public B f(A a) {
      * Lifts the function into the fully featured function wrapper
      */
     public static <A, B> F1W<A, B> lift(final F<A, B> f) {
-        return new F1WFunc<A, B>(f);
+        return new F1WFunc<>(f);
     }
 }
diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index 8d832798..87888fad 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -168,7 +168,7 @@ public static <A, B, C> F<F2<A, B, C>, F2<B, A, C>> flip2() {
    * not apply the value, instead returning an empty optional value.
    */
   public static <A, B> F<A, Option<B>> nullable(final F<A, B> f) {
-    return a -> a == null ? Option.<B>none() : Option.some(f.f(a));
+    return a -> a == null ? Option.none() : Option.some(f.f(a));
   }
 
   /**
@@ -761,7 +761,7 @@ public static <A, B, C, D> F<F<D, A>, F<F<D, B>, F<D, C>>> lift(final F<A, F<B,
    * @return A function of arity-1 whose argument is substituted for both parameters of <em>f</em>.
    */
   public static <A, B> F<B, A> join(final F<B, F<B, A>> f) {
-    return bind(f, Function.<F<B, A>>identity());
+    return bind(f, Function.identity());
   }
 
 
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index acb2a62c..3e6c0ae8 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -165,7 +165,7 @@ public static <A, B> Hash<Either<A, B>> eitherHash(final Hash<A> ha, final Hash<
    * @return A hash instance for the {@link Validation} type.
    */
   public static <A, B> Hash<Validation<A, B>> validationHash(final Hash<A> ha, final Hash<B> hb) {
-    return eitherHash(ha, hb).contramap(Validation.<A, B>either());
+    return eitherHash(ha, hb).contramap(Validation.either());
   }
 
   /**
@@ -196,7 +196,7 @@ public static <A> Hash<List<A>> listHash(final Hash<A> ha) {
    * @return A hash instance for the {@link NonEmptyList} type.
    */
   public static <A> Hash<NonEmptyList<A>> nonEmptyListHash(final Hash<A> ha) {
-    return listHash(ha).contramap(NonEmptyList.<A>toList_());
+    return listHash(ha).contramap(NonEmptyList.toList_());
   }
 
   /**
@@ -264,7 +264,7 @@ public static <A> Hash<Array<A>> arrayHash(final Hash<A> ha) {
    * @return A hash instance for the {@link Tree} type.
    */
   public static <A> Hash<Tree<A>> treeHash(final Hash<A> ha) {
-    return streamHash(ha).contramap(Tree.<A>flatten_());
+    return streamHash(ha).contramap(Tree.flatten_());
   }
 
     public static <K, V> Hash<TreeMap<K, V>> treeMapHash(final Hash<K> h, final Hash<V> v) {
@@ -278,7 +278,7 @@ public static <K, V> Hash<TreeMap<K, V>> treeMapHash(final Hash<K> h, final Hash
    * @return A hash instance for a product-1.
    */
   public static <A> Hash<P1<A>> p1Hash(final Hash<A> ha) {
-    return ha.contramap(P1.<A>__1());
+    return ha.contramap(P1.__1());
   }
 
   /**
@@ -473,7 +473,7 @@ public static <A, B, C, D, E> Hash<P5<A, B, C, D, E>> p5Hash(final Hash<A> ha, f
    * @return A hash instance for a vector-2.
    */
   public static <A> Hash<V2<A>> v2Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V2.<A>toStream_());
+    return streamHash(ea).contramap(V2.toStream_());
   }
 
   /**
@@ -483,7 +483,7 @@ public static <A> Hash<V2<A>> v2Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-3.
    */
   public static <A> Hash<V3<A>> v3Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V3.<A>toStream_());
+    return streamHash(ea).contramap(V3.toStream_());
   }
 
   /**
@@ -493,7 +493,7 @@ public static <A> Hash<V3<A>> v3Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-4.
    */
   public static <A> Hash<V4<A>> v4Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V4.<A>toStream_());
+    return streamHash(ea).contramap(V4.toStream_());
   }
 
   /**
@@ -503,7 +503,7 @@ public static <A> Hash<V4<A>> v4Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-5.
    */
   public static <A> Hash<V5<A>> v5Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V5.<A>toStream_());
+    return streamHash(ea).contramap(V5.toStream_());
   }
 
   /**
@@ -513,7 +513,7 @@ public static <A> Hash<V5<A>> v5Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-6.
    */
   public static <A> Hash<V6<A>> v6Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V6.<A>toStream_());
+    return streamHash(ea).contramap(V6.toStream_());
   }
 
   /**
@@ -523,7 +523,7 @@ public static <A> Hash<V6<A>> v6Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-7.
    */
   public static <A> Hash<V7<A>> v7Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V7.<A>toStream_());
+    return streamHash(ea).contramap(V7.toStream_());
   }
 
   /**
@@ -533,6 +533,6 @@ public static <A> Hash<V7<A>> v7Hash(final Hash<A> ea) {
    * @return A hash instance for a vector-8.
    */
   public static <A> Hash<V8<A>> v8Hash(final Hash<A> ea) {
-    return streamHash(ea).contramap(V8.<A>toStream_());
+    return streamHash(ea).contramap(V8.toStream_());
   }
 }
diff --git a/core/src/main/java/fj/LcgRng.java b/core/src/main/java/fj/LcgRng.java
index d2c244b6..50ee9e03 100644
--- a/core/src/main/java/fj/LcgRng.java
+++ b/core/src/main/java/fj/LcgRng.java
@@ -40,7 +40,7 @@ public P2<Rng, Long> nextLong() {
      */
     static P2<Long, Long> nextLong(long seed) {
         long newSeed = (seed * 0x5DEECE66DL + 0xBL) & 0xFFFFFFFFFFFFL;
-        long n = (Long) (newSeed >>> 16);
+        long n = newSeed >>> 16;
         return P.p(newSeed, n);
     }
 
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index be5215bb..af6d95f9 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -200,7 +200,7 @@ public A join(final Iterable<A> as, final A a) {
    * @return A monoid instance that uses the given sun function and zero value.
    */
   public static <A> Monoid<A> monoid(final F<A, F<A, A>> sum, final A zero) {
-    return new Monoid<A>(sum, zero);
+    return new Monoid<>(sum, zero);
   }
 
   /**
@@ -212,7 +212,7 @@ public static <A> Monoid<A> monoid(final F<A, F<A, A>> sum, final A zero) {
    * @return A monoid instance that uses the given sun function and zero value.
    */
   public static <A> Monoid<A> monoid(final F2<A, A, A> sum, final A zero) {
-    return new Monoid<A>(curry(sum), zero);
+    return new Monoid<>(curry(sum), zero);
   }
 
   /**
@@ -223,7 +223,7 @@ public static <A> Monoid<A> monoid(final F2<A, A, A> sum, final A zero) {
    * @return A monoid instance that uses the given sun function and zero value.
    */
   public static <A> Monoid<A> monoid(final Semigroup<A> s, final A zero) {
-    return new Monoid<A>(s.sum(), zero);
+    return new Monoid<>(s.sum(), zero);
   }
 
   /**
@@ -328,7 +328,7 @@ public static <A> Monoid<A> monoid(final Semigroup<A> s, final A zero) {
    * @return A monoid for functions.
    */
   public static <A, B> Monoid<F<A, B>> functionMonoid(final Monoid<B> mb) {
-    return monoid(Semigroup.<A, B>functionSemigroup(mb.semigroup()), Function.<A, B>constant(mb.zero));
+    return monoid(Semigroup.functionSemigroup(mb.semigroup()), Function.constant(mb.zero));
   }
 
   /**
@@ -337,7 +337,7 @@ public static <A, B> Monoid<F<A, B>> functionMonoid(final Monoid<B> mb) {
    * @return A monoid for lists.
    */
   public static <A> Monoid<List<A>> listMonoid() {
-    return monoid(Semigroup.<A>listSemigroup(), List.<A>nil());
+    return monoid(Semigroup.listSemigroup(), List.nil());
   }
 
   /**
@@ -346,7 +346,7 @@ public static <A> Monoid<List<A>> listMonoid() {
    * @return A monoid for options.
    */
   public static <A> Monoid<Option<A>> optionMonoid() {
-    return monoid(Semigroup.<A>optionSemigroup(), Option.<A>none());
+    return monoid(Semigroup.optionSemigroup(), Option.none());
   }
 
   /**
@@ -355,7 +355,7 @@ public static <A> Monoid<Option<A>> optionMonoid() {
    * @return A monoid for options that take the first available value.
    */
   public static <A> Monoid<Option<A>> firstOptionMonoid() {
-    return monoid(Semigroup.<A>firstOptionSemigroup(), Option.<A>none());
+    return monoid(Semigroup.firstOptionSemigroup(), Option.none());
   }
 
   /**
@@ -364,7 +364,7 @@ public static <A> Monoid<Option<A>> firstOptionMonoid() {
    * @return A monoid for options that take the last available value.
    */
   public static <A> Monoid<Option<A>> lastOptionMonoid() {
-    return monoid(Semigroup.<A>lastOptionSemigroup(), Option.<A>none());
+    return monoid(Semigroup.lastOptionSemigroup(), Option.none());
   }
 
   /**
@@ -373,7 +373,7 @@ public static <A> Monoid<Option<A>> lastOptionMonoid() {
    * @return A monoid for streams.
    */
   public static <A> Monoid<Stream<A>> streamMonoid() {
-    return monoid(Semigroup.<A>streamSemigroup(), Stream.<A>nil());
+    return monoid(Semigroup.streamSemigroup(), Stream.nil());
   }
 
   /**
@@ -383,7 +383,7 @@ public static <A> Monoid<Stream<A>> streamMonoid() {
    */
   @SuppressWarnings("unchecked")
   public static <A> Monoid<Array<A>> arrayMonoid() {
-    return monoid(Semigroup.<A>arraySemigroup(), Array.<A>empty());
+    return monoid(Semigroup.arraySemigroup(), Array.empty());
   }
 
   /**
@@ -405,7 +405,7 @@ public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
    * @return A monoid for sets whose elements have the given order.
    */
   public static <A> Monoid<Set<A>> setMonoid(final Ord<A> o) {
-    return monoid(Semigroup.<A>setSemigroup(), Set.empty(o));
+    return monoid(Semigroup.setSemigroup(), Set.empty(o));
   }
 
 }
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 57d7e389..471c110f 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -75,7 +75,7 @@ public Equal<A> equal() {
    * @return A new ord.
    */
   public <B> Ord<B> contramap(final F<B, A> f) {
-    return ord(F1Functions.o(F1Functions.o(F1Functions.<B, A, Ordering>andThen(f), this.f), f));
+    return ord(F1Functions.o(F1Functions.o(F1Functions.andThen(f), this.f), f));
   }
 
   /**
@@ -166,7 +166,7 @@ public A min(final A a1, final A a2) {
    * @return An order instance.
    */
   public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
-    return new Ord<A>(f);
+    return new Ord<>(f);
   }
 
   /**
@@ -262,7 +262,7 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
   /**
    * An order instance for the {@link Ordering} type.
    */
-  public static final Ord<Ordering> orderingOrd = Ord.<Ordering>ord(curry((o1, o2) -> o1 == o2 ?
+  public static final Ord<Ordering> orderingOrd = Ord.ord(curry((o1, o2) -> o1 == o2 ?
          Ordering.EQ :
          o1 == Ordering.LT ?
          Ordering.LT :
@@ -334,7 +334,7 @@ public static <A, B> Ord<Either<A, B>> eitherOrd(final Ord<A> oa, final Ord<B> o
    * @return An order instance for the {@link Validation} type.
    */
   public static <A, B> Ord<Validation<A, B>> validationOrd(final Ord<A> oa, final Ord<B> ob) {
-    return eitherOrd(oa, ob).contramap(Validation.<A, B>either());
+    return eitherOrd(oa, ob).contramap(Validation.either());
   }
 
   /**
@@ -374,7 +374,7 @@ public static <A> Ord<List<A>> listOrd(final Ord<A> oa) {
    * @return An order instance for the {@link NonEmptyList} type.
    */
   public static <A> Ord<NonEmptyList<A>> nonEmptyListOrd(final Ord<A> oa) {
-    return listOrd(oa).contramap(NonEmptyList.<A>toList_());
+    return listOrd(oa).contramap(NonEmptyList.toList_());
   }
 
   /**
@@ -443,7 +443,7 @@ public static <A> Ord<Set<A>> setOrd(final Ord<A> oa) {
    * @return An order instance for a product-1.
    */
   public static <A> Ord<P1<A>> p1Ord(final Ord<A> oa) {
-    return oa.contramap(P1.<A>__1());
+    return oa.contramap(P1.__1());
   }
 
 
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 796daf22..5a1d9b8a 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -114,7 +114,7 @@ public <B, C> P1<C> bind(final P1<B> cb, final F2<A, B, C> f) {
      * @return A new P1 that is the join of the given P1.
      */
     public static <A> P1<A> join(final P1<P1<A>> a) {
-        return a.bind(Function.<P1<A>>identity());
+        return a.bind(Function.identity());
     }
 
     /**
@@ -138,7 +138,7 @@ public <B, C> P1<C> liftM2(P1<B> pb, F2<A, B, C> f) {
      * @return A single P1 for the given List.
      */
     public static <A> P1<List<A>> sequence(final List<P1<A>> as) {
-        return as.foldRight(liftM2(List.<A>cons()), P.p(List.<A>nil()));
+        return as.foldRight(liftM2(List.cons()), P.p(List.nil()));
     }
 
     /**
@@ -157,7 +157,7 @@ public static <A> F<List<P1<A>>, P1<List<A>>> sequenceList() {
      * @return A single P1 for the given stream.
      */
     public static <A> P1<Stream<A>> sequence(final Stream<P1<A>> as) {
-        return as.foldRight(liftM2(Stream.<A>cons()), P.p(Stream.<A>nil()));
+        return as.foldRight(liftM2(Stream.cons()), P.p(Stream.nil()));
     }
 
 	/**
@@ -174,7 +174,7 @@ public static <A> P1<Option<A>> sequence(final Option<P1<A>> o) {
      * @return A single P1 for the given array.
      */
     public static <A> P1<Array<A>> sequence(final Array<P1<A>> as) {
-        return P.lazy(() -> as.map(P1.<A>__1()));
+        return P.lazy(() -> as.map(P1.__1()));
     }
 
     /**
@@ -341,7 +341,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object other) {
-        return Equal.equals0(P1.class, this, other, () -> Equal.p1Equal(Equal.<A>anyEqual()));
+        return Equal.equals0(P1.class, this, other, () -> Equal.p1Equal(Equal.anyEqual()));
     }
 
     @Override
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index d564df35..be3be69b 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -28,7 +28,7 @@ public abstract class P2<A, B> {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(P2.class, this, other, () -> Equal.p2Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual()));
+    return Equal.equals0(P2.class, this, other, () -> Equal.p2Equal(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
@@ -155,7 +155,7 @@ public final <C, X> Either<X, P2<A, C>> traverseEither(final F<B, Either<X, C>>
    */
   public final <C> Stream<C> sequenceW(final Stream<F<P2<A, B>, C>> fs) {
     return fs.isEmpty()
-           ? Stream.<C>nil()
+           ? Stream.nil()
            : Stream.cons(fs.head().f(this), () -> sequenceW(fs.tail()._1()));
   }
 
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index 8760562b..c6bc38a9 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -181,7 +181,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P3.class, this, other, 
-        () -> Equal.p3Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual()));
+        () -> Equal.p3Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index 7f71943e..6181b75e 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -250,7 +250,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P4.class, this, other,
-        () -> Equal.p4Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual(), Equal.<D>anyEqual()));
+        () -> Equal.p4Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 57199302..2fd74ebe 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -325,7 +325,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P5.class, this, other,
-        () -> Equal.p5Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual(), Equal.<D>anyEqual(), Equal.<E>anyEqual()));
+        () -> Equal.p5Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index d1f32b87..5c679a2c 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -355,7 +355,7 @@ public F _6() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, A> __1() {
-    return P6<A, B, C, D, E, F$>::_1;
+    return P6::_1;
   }
 
   /**
@@ -364,7 +364,7 @@ public F _6() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, B> __2() {
-    return P6<A, B, C, D, E, F$>::_2;
+    return P6::_2;
   }
 
   /**
@@ -373,7 +373,7 @@ public F _6() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, C> __3() {
-    return P6<A, B, C, D, E, F$>::_3;
+    return P6::_3;
   }
 
   /**
@@ -382,7 +382,7 @@ public F _6() {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, D> __4() {
-    return P6<A, B, C, D, E, F$>::_4;
+    return P6::_4;
   }
 
   /**
@@ -391,7 +391,7 @@ public F _6() {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, E> __5() {
-    return P6<A, B, C, D, E, F$>::_5;
+    return P6::_5;
   }
 
   /**
@@ -400,7 +400,7 @@ public F _6() {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$> fj.F<P6<A, B, C, D, E, F$>, F$> __6() {
-    return P6<A, B, C, D, E, F$>::_6;
+    return P6::_6;
   }
 
     @Override
@@ -412,7 +412,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P6.class, this, other,
-        () -> Equal.p6Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual(), Equal.<D>anyEqual(), Equal.<E>anyEqual(), Equal.<F>anyEqual()));
+        () -> Equal.p6Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index e81a2480..eb0cb913 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -437,7 +437,7 @@ public G _7() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, A> __1() {
-    return P7<A, B, C, D, E, F$, G>::_1;
+    return P7::_1;
   }
 
   /**
@@ -446,7 +446,7 @@ public G _7() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, B> __2() {
-    return P7<A, B, C, D, E, F$, G>::_2;
+    return P7::_2;
   }
 
   /**
@@ -455,7 +455,7 @@ public G _7() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, C> __3() {
-    return P7<A, B, C, D, E, F$, G>::_3;
+    return P7::_3;
   }
 
   /**
@@ -464,7 +464,7 @@ public G _7() {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, D> __4() {
-    return P7<A, B, C, D, E, F$, G>::_4;
+    return P7::_4;
   }
 
   /**
@@ -473,7 +473,7 @@ public G _7() {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, E> __5() {
-    return P7<A, B, C, D, E, F$, G>::_5;
+    return P7::_5;
   }
 
   /**
@@ -482,7 +482,7 @@ public G _7() {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, F$> __6() {
-    return P7<A, B, C, D, E, F$, G>::_6;
+    return P7::_6;
   }
 
   /**
@@ -491,7 +491,7 @@ public G _7() {
    * @return A function that returns the seventh element of a product.
    */
   public static <A, B, C, D, E, F$, G> fj.F<P7<A, B, C, D, E, F$, G>, G> __7() {
-    return P7<A, B, C, D, E, F$, G>::_7;
+    return P7::_7;
   }
 
   @Override
@@ -502,7 +502,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P7.class, this, other,
-        () -> Equal.p7Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual(), Equal.<D>anyEqual(), Equal.<E>anyEqual(), Equal.<F>anyEqual(), Equal.<G>anyEqual()));
+        () -> Equal.p7Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index 982dca58..de13749b 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -530,7 +530,7 @@ public H _8() {
    * @return A function that returns the first element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, A> __1() {
-    return P8<A, B, C, D, E, F$, G, H>::_1;
+    return P8::_1;
   }
 
   /**
@@ -539,7 +539,7 @@ public H _8() {
    * @return A function that returns the second element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, B> __2() {
-    return P8<A, B, C, D, E, F$, G, H>::_2;
+    return P8::_2;
   }
 
   /**
@@ -548,7 +548,7 @@ public H _8() {
    * @return A function that returns the third element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, C> __3() {
-    return P8<A, B, C, D, E, F$, G, H>::_3;
+    return P8::_3;
   }
 
   /**
@@ -557,7 +557,7 @@ public H _8() {
    * @return A function that returns the fourth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, D> __4() {
-    return P8<A, B, C, D, E, F$, G, H>::_4;
+    return P8::_4;
   }
 
   /**
@@ -566,7 +566,7 @@ public H _8() {
    * @return A function that returns the fifth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, E> __5() {
-    return P8<A, B, C, D, E, F$, G, H>::_5;
+    return P8::_5;
   }
 
   /**
@@ -575,7 +575,7 @@ public H _8() {
    * @return A function that returns the sixth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, F$> __6() {
-    return P8<A, B, C, D, E, F$, G, H>::_6;
+    return P8::_6;
   }
 
   /**
@@ -584,7 +584,7 @@ public H _8() {
    * @return A function that returns the seventh element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, G> __7() {
-    return P8<A, B, C, D, E, F$, G, H>::_7;
+    return P8::_7;
   }
 
   /**
@@ -593,7 +593,7 @@ public H _8() {
    * @return A function that returns the eighth element of a product.
    */
   public static <A, B, C, D, E, F$, G, H> fj.F<P8<A, B, C, D, E, F$, G, H>, H> __8() {
-    return P8<A, B, C, D, E, F$, G, H>::_8;
+    return P8::_8;
   }
 
   @Override
@@ -604,7 +604,7 @@ public String toString() {
   @Override
   public boolean equals(Object other) {
     return Equal.equals0(P8.class, this, other,
-        () -> Equal.p8Equal(Equal.<A>anyEqual(), Equal.<B>anyEqual(), Equal.<C>anyEqual(), Equal.<D>anyEqual(), Equal.<E>anyEqual(), Equal.<F>anyEqual(), Equal.<G>anyEqual(), Equal.<H>anyEqual()));
+        () -> Equal.p8Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index e7cd4c35..057596f5 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -103,7 +103,7 @@ static <A> A multiply1p(F<A, F<A, A>> sum, int n, A a) {
    * @return A semigroup from the given function.
    */
   public static <A> Semigroup<A> semigroup(final F<A, F<A, A>> sum) {
-    return new Semigroup<A>(sum);
+    return new Semigroup<>(sum);
   }
 
   /**
@@ -113,7 +113,7 @@ public static <A> Semigroup<A> semigroup(final F<A, F<A, A>> sum) {
    * @return A semigroup from the given function.
    */
   public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
-    return new Semigroup<A>(curry(sum));
+    return new Semigroup<>(curry(sum));
   }
 
   /**
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 5e6fd8b0..4d599693 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -282,7 +282,7 @@ public static <A> Show<List<A>> listShow(final Show<A> sa) {
    * @return A show instance for the {@link NonEmptyList} type.
    */
   public static <A> Show<NonEmptyList<A>> nonEmptyListShow(final Show<A> sa) {
-    return listShow(sa).contramap(NonEmptyList.<A>toList_());
+    return listShow(sa).contramap(NonEmptyList.toList_());
   }
 
   /**
@@ -557,7 +557,7 @@ public static <A, B, C, D, E> Show<P5<A, B, C, D, E>> p5Show(final Show<A> sa, f
    * @return A show instance for a vector-2.
    */
   public static <A> Show<V2<A>> v2Show(final Show<A> ea) {
-    return streamShow(ea, "V2(", ",", ")").contramap(V2.<A>toStream_());
+    return streamShow(ea, "V2(", ",", ")").contramap(V2.toStream_());
   }
 
   /**
@@ -567,7 +567,7 @@ public static <A> Show<V2<A>> v2Show(final Show<A> ea) {
    * @return A show instance for a vector-3.
    */
   public static <A> Show<V3<A>> v3Show(final Show<A> ea) {
-    return streamShow(ea, "V3(", ",", ")").contramap(V3.<A>toStream_());
+    return streamShow(ea, "V3(", ",", ")").contramap(V3.toStream_());
   }
 
   /**
@@ -577,7 +577,7 @@ public static <A> Show<V3<A>> v3Show(final Show<A> ea) {
    * @return A show instance for a vector-4.
    */
   public static <A> Show<V4<A>> v4Show(final Show<A> ea) {
-    return streamShow(ea, "V4(", ",", ")").contramap(V4.<A>toStream_());
+    return streamShow(ea, "V4(", ",", ")").contramap(V4.toStream_());
   }
 
   /**
@@ -587,7 +587,7 @@ public static <A> Show<V4<A>> v4Show(final Show<A> ea) {
    * @return A show instance for a vector-5.
    */
   public static <A> Show<V5<A>> v5Show(final Show<A> ea) {
-    return streamShow(ea, "V5(", ",", ")").contramap(V5.<A>toStream_());
+    return streamShow(ea, "V5(", ",", ")").contramap(V5.toStream_());
   }
 
   /**
@@ -597,7 +597,7 @@ public static <A> Show<V5<A>> v5Show(final Show<A> ea) {
    * @return A show instance for a vector-6.
    */
   public static <A> Show<V6<A>> v6Show(final Show<A> ea) {
-    return streamShow(ea, "V6(", ",", ")").contramap(V6.<A>toStream_());
+    return streamShow(ea, "V6(", ",", ")").contramap(V6.toStream_());
   }
 
   /**
@@ -607,7 +607,7 @@ public static <A> Show<V6<A>> v6Show(final Show<A> ea) {
    * @return A show instance for a vector-7.
    */
   public static <A> Show<V7<A>> v7Show(final Show<A> ea) {
-    return streamShow(ea, "V7(", ",", ")").contramap(V7.<A>toStream_());
+    return streamShow(ea, "V7(", ",", ")").contramap(V7.toStream_());
   }
 
   /**
@@ -617,7 +617,7 @@ public static <A> Show<V7<A>> v7Show(final Show<A> ea) {
    * @return A show instance for a vector-8.
    */
   public static <A> Show<V8<A>> v8Show(final Show<A> ea) {
-    return streamShow(ea, "V8(", ",", ")").contramap(V8.<A>toStream_());
+    return streamShow(ea, "V8(", ",", ")").contramap(V8.toStream_());
   }
 
   /**
@@ -643,7 +643,7 @@ public static <A> Show<Stream<A>> unlineShow(final Show<A> sa) {
   /**
    * A show instance for the empty heterogeneous Stream.
    */
-  public static final Show<HList.HNil> HListShow = showS(Function.<HList.HNil, String>constant("Nil"));
+  public static final Show<HList.HNil> HListShow = showS(Function.constant("Nil"));
 
   /**
    * A show instance for heterogeneous Streams.
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index a41c7a03..fa07df3c 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -108,7 +108,7 @@ public Either<P1<Trampoline<A>>, A> resume() {
 
   @SuppressWarnings("unchecked")
   protected static <A, B> Codense<B> codense(final Normal<A> a, final F<A, Trampoline<B>> k) {
-    return new Codense<B>((Normal<Object>) a, (F<Object, Trampoline<B>>) k);
+    return new Codense<>((Normal<Object>) a, (F<Object, Trampoline<B>>) k);
   }
 
   /**
@@ -125,7 +125,7 @@ public static <A> F<A, Trampoline<A>> pure() {
    * @return A trampoline that results in the given value.
    */
   public static <A> Trampoline<A> pure(final A a) {
-    return new Pure<A>(a);
+    return new Pure<>(a);
   }
 
   /**
@@ -135,7 +135,7 @@ public static <A> Trampoline<A> pure(final A a) {
    * @return A trampoline whose next step runs the given thunk.
    */
   public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
-    return new Suspend<A>(a);
+    return new Suspend<>(a);
   }
 
   /**
@@ -162,7 +162,7 @@ public static <A> F<P1<Trampoline<A>>, Trampoline<A>> suspend_() {
    * @return A new trampoline that runs this trampoline, then applies the given function to the result.
    */
   public final <B> Trampoline<B> map(final F<A, B> f) {
-    return bind(F1Functions.o(Trampoline.<B>pure(), f));
+    return bind(F1Functions.o(Trampoline.pure(), f));
   }
 
   /**
@@ -257,7 +257,7 @@ public <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B, C> f)
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(P.<Trampoline<C>>lazy(() -> ta.zipWith(tb, f))))));
+        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(P.lazy(() -> ta.zipWith(tb, f))))));
       }
       for (final B y : eb.right()) {
         return suspend(x.map(ta -> ta.map(F2Functions.f(F2Functions.flip(f), y))));
diff --git a/core/src/main/java/fj/control/db/DB.java b/core/src/main/java/fj/control/db/DB.java
index 8e8590b6..a7ba6a7f 100644
--- a/core/src/main/java/fj/control/db/DB.java
+++ b/core/src/main/java/fj/control/db/DB.java
@@ -103,6 +103,6 @@ public B run(final Connection c) throws SQLException {
    * @return A new database action equivalent to the result of the given action.
    */
   public static <A> DB<A> join(final DB<DB<A>> a) {
-    return a.bind(Function.<DB<A>>identity());
+    return a.bind(Function.identity());
   }
 }
diff --git a/core/src/main/java/fj/control/parallel/Actor.java b/core/src/main/java/fj/control/parallel/Actor.java
index bd1956bd..c5985c7c 100644
--- a/core/src/main/java/fj/control/parallel/Actor.java
+++ b/core/src/main/java/fj/control/parallel/Actor.java
@@ -33,13 +33,13 @@ public final class Actor<A> {
    * as they are sent.
    */
   public static <T> Actor<T> queueActor(final Strategy<Unit> s, final Effect1<T> ea) {
-    return actor(Strategy.<Unit>seqStrategy(), new Effect1<T>() {
+    return actor(Strategy.seqStrategy(), new Effect1<T>() {
 
       // Lock to ensure the actor only acts on one message at a time
       final AtomicBoolean suspended = new AtomicBoolean(true);
 
       // Queue to hold pending messages
-      final ConcurrentLinkedQueue<T> mbox = new ConcurrentLinkedQueue<T>();
+      final ConcurrentLinkedQueue<T> mbox = new ConcurrentLinkedQueue<>();
 
       // Product so the actor can use its strategy (to act on messages in other threads,
       // to handle exceptions, etc.)
@@ -90,7 +90,7 @@ private Actor(final Strategy<Unit> s, final F<A, P1<Unit>> e) {
    * @return A new actor that uses the given parallelization strategy and has the given side-effect.
    */
   public static <A> Actor<A> actor(final Strategy<Unit> s, final Effect1<A> e) {
-    return new Actor<A>(s, P1.curry(Effect.f(e)));
+    return new Actor<>(s, P1.curry(Effect.f(e)));
   }
 
   /**
@@ -101,7 +101,7 @@ public static <A> Actor<A> actor(final Strategy<Unit> s, final Effect1<A> e) {
    * @return A new actor that uses the given parallelization strategy and has the given side-effect.
    */
   public static <A> Actor<A> actor(final Strategy<Unit> s, final F<A, P1<Unit>> e) {
-    return new Actor<A>(s, e);
+    return new Actor<>(s, e);
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Callables.java b/core/src/main/java/fj/control/parallel/Callables.java
index 7c2a7221..995780c4 100644
--- a/core/src/main/java/fj/control/parallel/Callables.java
+++ b/core/src/main/java/fj/control/parallel/Callables.java
@@ -126,7 +126,7 @@ public static <A, B, C> Callable<C> bind(final Callable<A> ca, final Callable<B>
    * @return A new Callable that is the join of the given Callable.
    */
   public static <A> Callable<A> join(final Callable<Callable<A>> a) {
-    return bind(a, Function.<Callable<A>>identity());
+    return bind(a, Function.identity());
   }
 
   /**
@@ -146,8 +146,7 @@ public static <A, B, C> F<Callable<A>, F<Callable<B>, Callable<C>>> liftM2(final
    * @return A single callable for the given List.
    */
   public static <A> Callable<List<A>> sequence(final List<Callable<A>> as) {
-    return as.foldRight(Callables.<A, List<A>,
-        List<A>>liftM2(List.<A>cons()), callable(List.<A>nil()));
+    return as.foldRight(Callables.liftM2(List.cons()), callable(List.nil()));
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/ParModule.java b/core/src/main/java/fj/control/parallel/ParModule.java
index 7e0fdb59..514988aa 100644
--- a/core/src/main/java/fj/control/parallel/ParModule.java
+++ b/core/src/main/java/fj/control/parallel/ParModule.java
@@ -261,7 +261,7 @@ public <A, B> F<F<A, B>, F<List<A>, Promise<List<B>>>> parMapList() {
    * @return A Promise of a new NonEmptyList with the given function applied to each element.
    */
   public <A, B> Promise<NonEmptyList<B>> parMap(final NonEmptyList<A> as, final F<A, B> f) {
-    return mapM(as.toList(), promise(f)).fmap((F<List<B>, NonEmptyList<B>>) list -> NonEmptyList.fromList(list).some());
+    return mapM(as.toList(), promise(f)).fmap(list -> NonEmptyList.fromList(list).some());
   }
 
   /**
@@ -293,7 +293,7 @@ public <A, B> F<F<A, B>, F<Stream<A>, Promise<Stream<B>>>> parMapStream() {
    */
   public <A, B> Promise<Iterable<B>> parMap(final Iterable<A> as, final F<A, B> f) {
     return parMap(iterableStream(as), f)
-        .fmap(Function.<Stream<B>, Iterable<B>>vary(Function.<Stream<B>>identity()));
+        .fmap(Function.vary(Function.identity()));
   }
 
   /**
@@ -334,7 +334,7 @@ public <A, B> F<F<A, B>, F<Array<A>, Promise<Array<B>>>> parMapArray() {
    */
   public <A, B> Promise<Zipper<B>> parMap(final Zipper<A> za, final F<A, B> f) {
     return parMap(za.rights(), f)
-        .apply(promise(f).f(za.focus()).apply(parMap(za.lefts(), f).fmap(curry(Zipper.<B>zipper()))));
+        .apply(promise(f).f(za.focus()).apply(parMap(za.lefts(), f).fmap(curry(Zipper.zipper()))));
   }
 
   /**
@@ -346,7 +346,7 @@ public <A, B> Promise<Zipper<B>> parMap(final Zipper<A> za, final F<A, B> f) {
    */
   public <A, B> Promise<Tree<B>> parMap(final Tree<A> ta, final F<A, B> f) {
     return mapM(ta.subForest(), this.<Tree<A>, Tree<B>>mapStream().f(this.<A, B>parMapTree().f(f)))
-        .apply(promise(f).f(ta.root()).fmap(Tree.<B>node()));
+        .apply(promise(f).f(ta.root()).fmap(Tree.node()));
   }
 
   /**
@@ -370,8 +370,8 @@ public <A, B> Promise<TreeZipper<B>> parMap(final TreeZipper<A> za, final F<A, B
     final P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>> p = za.p();
     return mapM(p._4(),
             p3 -> parMap(p3._3(), tf).apply(promise(f).f(p3._2()).apply(
-                parMap(p3._1(), tf).fmap(P.<Stream<Tree<B>>, B, Stream<Tree<B>>>p3())))).apply(parMap(za.rights(), tf).apply(
-        parMap(za.lefts(), tf).apply(parMap(p._1(), f).fmap(TreeZipper.<B>treeZipper()))));
+                parMap(p3._1(), tf).fmap(P.p3())))).apply(parMap(za.rights(), tf).apply(
+        parMap(za.lefts(), tf).apply(parMap(p._1(), f).fmap(TreeZipper.treeZipper()))));
   }
 
   /**
@@ -382,7 +382,7 @@ public <A, B> Promise<TreeZipper<B>> parMap(final TreeZipper<A> za, final F<A, B
    * @return A promise of a new List with the given function bound across its elements.
    */
   public <A, B> Promise<List<B>> parFlatMap(final List<A> as, final F<A, List<B>> f) {
-    return parFoldMap(as, f, Monoid.<B>listMonoid());
+    return parFoldMap(as, f, Monoid.listMonoid());
   }
 
   /**
@@ -393,7 +393,7 @@ public <A, B> Promise<List<B>> parFlatMap(final List<A> as, final F<A, List<B>>
    * @return A promise of a new Stream with the given function bound across its elements.
    */
   public <A, B> Promise<Stream<B>> parFlatMap(final Stream<A> as, final F<A, Stream<B>> f) {
-    return parFoldMap(as, f, Monoid.<B>streamMonoid());
+    return parFoldMap(as, f, Monoid.streamMonoid());
   }
 
   /**
@@ -404,7 +404,7 @@ public <A, B> Promise<Stream<B>> parFlatMap(final Stream<A> as, final F<A, Strea
    * @return A promise of a new Array with the given function bound across its elements.
    */
   public <A, B> Promise<Array<B>> parFlatMap(final Array<A> as, final F<A, Array<B>> f) {
-    return parMap(as, f).fmap(Array.<B>join());
+    return parMap(as, f).fmap(Array.join());
   }
 
   /**
@@ -415,8 +415,8 @@ public <A, B> Promise<Array<B>> parFlatMap(final Array<A> as, final F<A, Array<B
    * @return A promise of a new Iterable with the given function bound across its elements.
    */
   public <A, B> Promise<Iterable<B>> parFlatMap(final Iterable<A> as, final F<A, Iterable<B>> f) {
-    return parMap(as, f).fmap(IterableW.<B, Iterable<B>>join())
-        .fmap(Function.<IterableW<B>, Iterable<B>>vary(Function.<Iterable<B>>identity()));
+    return parMap(as, f).fmap(IterableW.join())
+        .fmap(Function.vary(Function.<Iterable<B>>identity()));
   }
 
   /**
@@ -428,7 +428,7 @@ public <A, B> Promise<Iterable<B>> parFlatMap(final Iterable<A> as, final F<A, I
    * @return A Promise of a new list with the results of applying the given function across the two lists in lockstep.
    */
   public <A, B, C> Promise<List<C>> parZipWith(final List<A> as, final List<B> bs, final F<A, F<B, C>> f) {
-    return sequence(as.<B, Promise<C>>zipWith(bs, promise(uncurryF2(f))));
+    return sequence(as.zipWith(bs, promise(uncurryF2(f))));
   }
 
   /**
@@ -440,7 +440,7 @@ public <A, B, C> Promise<List<C>> parZipWith(final List<A> as, final List<B> bs,
    * @return A Promise of a new stream with the results of applying the given function across the two streams, stepwise.
    */
   public <A, B, C> Promise<Stream<C>> parZipWith(final Stream<A> as, final Stream<B> bs, final F<A, F<B, C>> f) {
-    return sequence(as.<B, Promise<C>>zipWith(bs, promise(uncurryF2(f))));
+    return sequence(as.zipWith(bs, promise(uncurryF2(f))));
   }
 
   /**
@@ -465,7 +465,7 @@ public <A, B, C> Promise<Array<C>> parZipWith(final Array<A> as, final Array<B>
    */
   public <A, B, C> Promise<Iterable<C>> parZipWith(final Iterable<A> as, final Iterable<B> bs, final F<A, F<B, C>> f) {
     return parZipWith(iterableStream(as), iterableStream(bs), f).fmap(
-        Function.<Stream<C>, Iterable<C>>vary(Function.<Iterable<C>>identity()));
+        Function.vary(Function.<Iterable<C>>identity()));
   }
 
   /**
@@ -496,7 +496,7 @@ public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final
    */
   public <A, B> Promise<B> parFoldMap(final Stream<A> as, final F<A, B> map, final Monoid<B> reduce,
                                       final F<Stream<A>, P2<Stream<A>, Stream<A>>> chunking) {
-    return parMap(Stream.unfold(stream -> stream.isEmpty() ? Option.<P2<Stream<A>, Stream<A>>>none() : some(chunking.f(stream)), as), Stream.<A, B>map_().f(map)).bind(stream -> parMap(stream, reduce.sumLeftS()).fmap(reduce.sumLeftS()));
+    return parMap(Stream.unfold(stream -> stream.isEmpty() ? Option.none() : some(chunking.f(stream)), as), Stream.<A, B>map_().f(map)).bind(stream -> parMap(stream, reduce.sumLeftS()).fmap(reduce.sumLeftS()));
   }
 
   /**
diff --git a/core/src/main/java/fj/control/parallel/Promise.java b/core/src/main/java/fj/control/parallel/Promise.java
index fc20f491..3689c286 100644
--- a/core/src/main/java/fj/control/parallel/Promise.java
+++ b/core/src/main/java/fj/control/parallel/Promise.java
@@ -37,7 +37,7 @@ public final class Promise<A> {
 
   private final CountDownLatch l = new CountDownLatch(1);
   private volatile Option<A> v = none();
-  private final Queue<Actor<A>> waiting = new LinkedList<Actor<A>>();
+  private final Queue<Actor<A>> waiting = new LinkedList<>();
 
   private Promise(final Strategy<Unit> s, final Actor<P2<Either<P1<A>, Actor<A>>, Promise<A>>> qa) {
     this.s = s;
@@ -62,7 +62,7 @@ public void f(final P2<Either<P1<A>, Actor<A>>, Promise<A>> p) {
               p._1().right().value().act(snd.v.some());
           }
         });
-    return new Promise<A>(s, q);
+    return new Promise<>(s, q);
   }
 
   /**
@@ -75,7 +75,7 @@ public void f(final P2<Either<P1<A>, Actor<A>>, Promise<A>> p) {
    */
   public static <A> Promise<A> promise(final Strategy<Unit> s, final P1<A> a) {
     final Promise<A> p = mkPromise(s);
-    p.actor.act(p(Either.<P1<A>, Actor<A>>left(a), p));
+    p.actor.act(p(Either.left(a), p));
     return p;
   }
 
@@ -118,7 +118,7 @@ public static <A, B> F<A, Promise<B>> promise(final Strategy<Unit> s, final F<A,
    * @param a An actor that will receive this Promise's value in the future.
    */
   public void to(final Actor<A> a) {
-    actor.act(p(Either.<P1<A>, Actor<A>>right(a), this));
+    actor.act(p(Either.right(a), this));
   }
 
   /**
@@ -176,7 +176,7 @@ public <B> Promise<B> bind(final F<A, Promise<B>> f) {
     final Promise<B> r = mkPromise(s);
     final Actor<B> ab = actor(s, new Effect1<B>() {
       public void f(final B b) {
-        r.actor.act(p(Either.<P1<B>, Actor<B>>left(p(b)), r));
+        r.actor.act(p(Either.left(p(b)), r));
       }
     });
     to(ab.promise().contramap(f));
@@ -254,7 +254,7 @@ public static <A> F<List<Promise<A>>, Promise<List<A>>> sequence(final Strategy<
    * @return A single promise for the given Stream.
    */
   public static <A> Promise<Stream<A>> sequence(final Strategy<Unit> s, final Stream<Promise<A>> as) {
-    return join(foldRightS(s, curry((Promise<A> o, P1<Promise<Stream<A>>> p) -> o.bind(a -> p._1().fmap(Stream.<A>cons_().f(a)))), promise(s, p(Stream.<A>nil()))).f(as));
+    return join(foldRightS(s, curry((Promise<A> o, P1<Promise<Stream<A>>> p) -> o.bind(a -> p._1().fmap(Stream.<A>cons_().f(a)))), promise(s, p(Stream.nil()))).f(as));
   }
 
   /**
@@ -275,7 +275,7 @@ public static <A> F<List<Promise<A>>, Promise<List<A>>> sequenceS(final Strategy
    * @return A promised product.
    */
   public static <A> Promise<P1<A>> sequence(final Strategy<Unit> s, final P1<Promise<A>> p) {
-    return join(promise(s, p)).fmap(P.<A>p1());
+    return join(promise(s, p)).fmap(P.p1());
   }
 
   /**
@@ -308,7 +308,7 @@ public static <A, B> F<Stream<A>, Promise<B>> foldRightS(final Strategy<Unit> s,
     return new F<Stream<A>, Promise<B>>() {
       public Promise<B> f(final Stream<A> as) {
         return as.isEmpty() ? promise(s, p(b)) : liftM2(f).f(promise(s, p(as.head()))).f(
-                Promise.<P1<B>>join(s, P.lazy(() -> f(as.tail()._1()).fmap(P.<B>p1()))));
+                Promise.join(s, P.lazy(() -> f(as.tail()._1()).fmap(P.p1()))));
       }
     };
   }
@@ -381,7 +381,7 @@ public Promise<Promise<A>> cojoin() {
    */
   public <B> Stream<B> sequenceW(final Stream<F<Promise<A>, B>> fs) {
     return fs.isEmpty()
-           ? Stream.<B>nil()
+           ? Stream.nil()
            : Stream.cons(fs.head().f(this), () -> sequenceW(fs.tail()._1()));
   }
 
diff --git a/core/src/main/java/fj/control/parallel/Strategy.java b/core/src/main/java/fj/control/parallel/Strategy.java
index 94e1f148..2b77a9e8 100644
--- a/core/src/main/java/fj/control/parallel/Strategy.java
+++ b/core/src/main/java/fj/control/parallel/Strategy.java
@@ -51,7 +51,7 @@ public F<P1<A>, P1<A>> f() {
    * @return A strategy that uses the given function to evaluate product-1s.
    */
   public static <A> Strategy<A> strategy(final F<P1<A>, P1<A>> f) {
-    return new Strategy<A>(f);
+    return new Strategy<>(f);
   }
 
   /**
@@ -71,7 +71,7 @@ public P1<A> par(final P1<A> a) {
    * @return A function that executes concurrently when called, yielding a Future value.
    */
   public <B> F<B, P1<A>> concurry(final F<B, A> f) {
-    return compose(f(), P1.<B, A>curry(f));
+    return compose(f(), P1.curry(f));
   }
 
   /**
@@ -91,7 +91,7 @@ public <B, C> F<B, F<C, P1<A>>> concurry(final F2<B, C, A> f) {
    * @return A list of values extracted from the Futures in the argument list.
    */
   public static <A> List<P1<A>> mergeAll(final List<Future<A>> xs) {
-    return xs.map(Strategy.<A>obtain());
+    return xs.map(Strategy.obtain());
   }
 
   /**
@@ -136,7 +136,7 @@ public <B> P1<Array<A>> parMap(final F<B, A> f, final Array<B> bs) {
    * @return A list with all of its elements transformed by the given function.
    */
   public <B> List<A> parMap1(final F<B, A> f, final List<B> bs) {
-    return compose(P1.<List<A>>__1(), parMapList(f)).f(bs);
+    return compose(P1.__1(), parMapList(f)).f(bs);
   }
 
   /**
@@ -149,7 +149,7 @@ public <B> List<A> parMap1(final F<B, A> f, final List<B> bs) {
    * @return An array with all of its elements transformed by the given function.
    */
   public <B> Array<A> parMap1(final F<B, A> f, final Array<B> bs) {
-    return compose(P1.<Array<A>>__1(), parMapArray(f)).f(bs);
+    return compose(P1.__1(), parMapArray(f)).f(bs);
   }
 
   /**
@@ -248,7 +248,7 @@ public static <A, B> P1<Array<B>> parFlatMap(final Strategy<Array<B>> s,
   public static <A> P1<List<A>> parListChunk(final Strategy<List<A>> s,
                                              final int chunkLength,
                                              final List<P1<A>> as) {
-    return P1.map_(List.<A>join()).f(s.parList(as.partition(chunkLength).map(P1.<A>sequenceList())));
+    return P1.map_(List.<A>join()).f(s.parList(as.partition(chunkLength).map(P1.sequenceList())));
   }
 
   /**
@@ -351,7 +351,7 @@ public static <A> Effect1<Future<A>> discard() {
    */
   public static <A> Strategy<A> simpleThreadStrategy() {
     return strategy(p -> {
-      final FutureTask<A> t = new FutureTask<A>(Java.<A>P1_Callable().f(p));
+      final FutureTask<A> t = new FutureTask<>(Java.<A>P1_Callable().f(p));
       new Thread(t).start();
       return obtain(t);
     });
@@ -396,7 +396,7 @@ public static <A> Strategy<A> seqStrategy() {
    * @return A strategy that performs no evaluation of its argument.
    */
   public static <A> Strategy<A> idStrategy() {
-    return strategy(Function.<P1<A>>identity());
+    return strategy(Function.identity());
   }
 
   /**
@@ -417,7 +417,7 @@ public <B> Strategy<B> xmap(final F<P1<A>, P1<B>> f, final F<P1<B>, P1<A>> g) {
    * @return A new strategy that applies the given transformation after each application of this strategy.
    */
   public Strategy<A> map(final F<P1<A>, P1<A>> f) {
-    return xmap(f, Function.<P1<A>>identity());
+    return xmap(f, Function.identity());
   }
 
   /**
@@ -427,7 +427,7 @@ public Strategy<A> map(final F<P1<A>, P1<A>> f) {
    * @return A new strategy that applies the given transformation before each application of this strategy.
    */
   public Strategy<A> contramap(final F<P1<A>, P1<A>> f) {
-    return xmap(Function.<P1<A>>identity(), f);
+    return xmap(Function.identity(), f);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/$.java b/core/src/main/java/fj/data/$.java
index 212216bc..17b2ac9e 100644
--- a/core/src/main/java/fj/data/$.java
+++ b/core/src/main/java/fj/data/$.java
@@ -30,7 +30,7 @@ public final class $<A, B> extends P1<B> {
 	}
 
 	public static <A, B> $<A, B> constant(final B b) {
-		return new $<A, B>(b);
+		return new $<>(b);
 	}
 
 
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index 7890a0c8..09b56f9a 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -88,7 +88,7 @@ public int length() {
   }
 
   public ImmutableProjection<A> immutable() {
-    return new ImmutableProjection<A>(this);
+    return new ImmutableProjection<>(this);
   }
 
   /**
@@ -148,7 +148,7 @@ public A[] toJavaArray() {
    */
   @SuppressWarnings("unchecked")
   public Option<A> toOption() {
-    return a.length == 0 ? Option.<A>none() : some((A) a[0]);
+    return a.length == 0 ? Option.none() : some((A) a[0]);
   }
 
   /**
@@ -160,7 +160,7 @@ public Option<A> toOption() {
    */
   @SuppressWarnings("unchecked")
   public <X> Either<X, A> toEither(final F0<X> x) {
-    return a.length == 0 ? Either.<X, A> left(x.f()) : Either.<X, A> right((A) a[0]);
+    return a.length == 0 ? Either.left(x.f()) : Either.right((A) a[0]);
   }
 
   /**
@@ -187,7 +187,7 @@ public List<A> toList() {
   @SuppressWarnings("unchecked")
   public Stream<A> toStream() {
     return Stream.unfold(o ->
-        a.length > o ? some(p((A) a[o], o + 1)) : Option.<P2<A, Integer>>none(), 0
+        a.length > o ? some(p((A) a[o], o + 1)) : Option.none(), 0
     );
   }
 
@@ -210,7 +210,7 @@ public <B> Array<B> map(final F<A, B> f) {
       bs[i] = f.f((A) a[i]);
     }
 
-    return new Array<B>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -333,7 +333,7 @@ public <B> Array<B> scanLeft(final F<B, F<A, B>> f, final B b) {
       bs[i] = x;
     }
     
-    return new Array<B>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -368,7 +368,7 @@ public Array<A> scanLeft1(final F<A, F<A, A>> f) {
       bs[i] = x;
     }
 
-    return new Array<A>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -402,7 +402,7 @@ public <B> Array<B> scanRight(final F<A, F<B, B>>f, final B b) {
       bs[i] = x;
     }
 
-    return new Array<B>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -437,7 +437,7 @@ public Array<A> scanRight1(final F<A, F<A, A>>f) {
       bs[i] = x;
     }
 
-    return new Array<A>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -482,7 +482,7 @@ public Unit f(final Array<B> x) {
       }
     });
 
-    return new Array<B>(bs);
+    return new Array<>(bs);
   }
 
   /**
@@ -542,7 +542,7 @@ public Array<A> reverse() {
       x[a.length - 1 - i] = a[i];
     }
 
-    return new Array<A>(x);
+    return new Array<>(x);
   }
 
   /**
@@ -557,7 +557,7 @@ public Array<A> append(final Array<A> aas) {
     arraycopy(a, 0, x, 0, a.length);
     arraycopy(aas.a, 0, x, a.length, aas.a.length);
 
-    return new Array<A>(x);
+    return new Array<>(x);
   }
 
   /**
@@ -566,7 +566,7 @@ public Array<A> append(final Array<A> aas) {
    * @return An empty array.
    */
   public static <A> Array<A> empty() {
-    return new Array<A>(new Object[0]);
+    return new Array<>(new Object[0]);
   }
 
   /**
@@ -587,7 +587,7 @@ public static <A> Array<A> array(final A...as) {
    * @return A wrapped array.
    */
   static <A> Array<A> mkArray(final Object[] a) {
-    return new Array<A>(a);
+    return new Array<>(a);
   }
 
   /**
@@ -597,7 +597,7 @@ static <A> Array<A> mkArray(final Object[] a) {
    * @return An array with the given single element.
    */
   public static <A> Array<A> single(final A a) {
-    return new Array<A>(new Object[]{a});
+    return new Array<>(new Object[]{a});
   }
 
   /**
@@ -674,7 +674,7 @@ public boolean exists(final F<A, Boolean> f) {
 
   @Override
   public boolean equals(Object o) {
-    return Equal.equals0(Array.class, this, o, () -> Equal.arrayEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Array.class, this, o, () -> Equal.arrayEqual(Equal.anyEqual()));
   }
 
   /**
@@ -707,7 +707,7 @@ public static Array<Integer> range(final int from, final int to) {
     if (from >= to)
       return empty();
     else {
-      final Array<Integer> a = new Array<Integer>(new Integer[to - from]);
+      final Array<Integer> a = new Array<>(new Integer[to - from]);
 
       for (int i = from; i < to; i++)
         a.set(i - from, i);
@@ -727,7 +727,7 @@ public static Array<Integer> range(final int from, final int to) {
    */
   public <B, C> Array<C> zipWith(final Array<B> bs, final F<A, F<B, C>> f) {
     final int len = min(a.length, bs.length());
-    final Array<C> x = new Array<C>(new Object[len]);
+    final Array<C> x = new Array<>(new Object[len]);
 
     for (int i = 0; i < len; i++) {
       x.set(i, f.f(get(i)).f(bs.get(i)));
@@ -812,7 +812,7 @@ public int size() {
    * Returns a standard java.util.List projection of this array.
    */
   java.util.List<A> toJavaList() {
-    return new ArrayList<A>(toCollection());
+    return new ArrayList<>(toCollection());
   }
 
   /**
@@ -840,7 +840,7 @@ public static <A> Array<A> iteratorArray(final Iterator<A> i) {
    */
   @SafeVarargs
   public static <A> Array<A> arrayArray(final A...as) {
-    return new Array<A>(as);
+    return new Array<>(as);
   }
 
   /**
@@ -852,8 +852,8 @@ public static <A> Array<A> arrayArray(final A...as) {
   @SuppressWarnings("unchecked")
   public static <A, B> P2<Array<A>, Array<B>> unzip(final Array<P2<A, B>> xs) {
     final int len = xs.length();
-    final Array<A> aa = new Array<A>(new Object[len]);
-    final Array<B> ab = new Array<B>(new Object[len]);
+    final Array<A> aa = new Array<>(new Object[len]);
+    final Array<B> ab = new Array<>(new Object[len]);
     for (int i = len - 1; i >= 0; i--) {
       final P2<A, B> p = xs.get(i);
       aa.set(i, p._1());
diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index 7e44ef9b..cf2f0af5 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -69,7 +69,7 @@ public static <A> DList<A> arrayDList(final A...as) {
      * @return the final List
      */
     public List<A> run() {
-        return appendFn.f(List.<A>nil()).run();
+        return appendFn.f(List.nil()).run();
     }
 
     /**
@@ -85,7 +85,7 @@ public java.util.List toJavaList() {
      * @return a empty DList.
      */
     public static <A> DList<A> nil() {
-        return new DList<>(Trampoline.<List<A>>pure());
+        return new DList<>(Trampoline.pure());
     }
     
     /**
diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 1cbecb5d..0d944415 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -39,7 +39,7 @@ private Either() {
    * @return A left projection of this either.
    */
   public final LeftProjection<A, B> left() {
-    return new LeftProjection<A, B>(this);
+    return new LeftProjection<>(this);
   }
 
   /**
@@ -48,7 +48,7 @@ public final LeftProjection<A, B> left() {
    * @return A right projection of this either.
    */
   public final RightProjection<A, B> right() {
-    return new RightProjection<A, B>(this);
+    return new RightProjection<>(this);
   }
 
   /**
@@ -93,7 +93,7 @@ public final <X, Y> Either<X, Y> bimap(final F<A, X> left, final F<B, Y> right)
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Either.class, this, other, () -> Equal.eitherEqual(Equal.<A>anyEqual(), Equal.<B>anyEqual()));
+    return Equal.equals0(Either.class, this, other, () -> Equal.eitherEqual(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
@@ -107,7 +107,7 @@ public int hashCode() {
    * @return The value of this either swapped to the opposing side.
    */
   public final Either<B, A> swap() {
-    return isLeft() ? new Right<B, A>(((Left<A, B>) this).a) : new Left<B, A>(((Right<A, B>) this).b);
+    return isLeft() ? new Right<>(((Left<A, B>) this).a) : new Left<>(((Right<A, B>) this).b);
   }
 
   private static final class Left<A, B> extends Either<A, B> {
@@ -265,7 +265,7 @@ public void foreachDoEffect(final Effect1<A> f) {
      * @return A new either value after mapping.
      */
     public <X> Either<X, B> map(final F<A, X> f) {
-      return isLeft() ? new Left<X, B>(f.f(value())) : new Right<X, B>(e.right().value());
+      return isLeft() ? new Left<>(f.f(value())) : new Right<>(e.right().value());
     }
 
     /**
@@ -275,7 +275,7 @@ public <X> Either<X, B> map(final F<A, X> f) {
      * @return A new either value after binding.
      */
     public <X> Either<X, B> bind(final F<A, Either<X, B>> f) {
-      return isLeft() ? f.f(value()) : new Right<X, B>(e.right().value());
+      return isLeft() ? f.f(value()) : new Right<>(e.right().value());
     }
 
     /**
@@ -285,7 +285,7 @@ public <X> Either<X, B> bind(final F<A, Either<X, B>> f) {
      * @return An either after binding through this projection.
      */
     public <X> Either<X, B> sequence(final Either<X, B> e) {
-      return bind(Function.<A, Either<X, B>>constant(e));
+      return bind(Function.constant(e));
     }
 
       /**
@@ -297,7 +297,7 @@ public <X> Either<X, B> sequence(final Either<X, B> e) {
       public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
           return isLeft() ?
                   f.f(value()).map(Either::<C, B>left) :
-                  list(Either.<C, B>right(e.right().value()));
+                  list(Either.right(e.right().value()));
       }
 
       /**
@@ -309,7 +309,7 @@ public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
       public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
           return isRight() ?
                   IOFunctions.map(f.f(value()), Either::<C, B>left) :
-                  IOFunctions.unit(Either.<C, B>right(e.right().value()));
+                  IOFunctions.unit(Either.right(e.right().value()));
       }
 
     /**
@@ -323,9 +323,9 @@ public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
     public <X> Option<Either<A, X>> filter(final F<A, Boolean> f) {
       return isLeft() ?
              f.f(value()) ?
-             Option.<Either<A, X>>some(new Left<>(value())) :
-             Option.<Either<A, X>>none() :
-             Option.<Either<A, X>>none();
+             Option.some(new Left<>(value())) :
+             Option.none() :
+             Option.none();
     }
 
     /**
@@ -368,7 +368,7 @@ public boolean exists(final F<A, Boolean> f) {
      * @return A single element list if this projection has a value, otherwise an empty list.
      */
     public List<A> toList() {
-      return isLeft() ? single(value()) : List.<A>nil();
+      return isLeft() ? single(value()) : List.nil();
     }
 
     /**
@@ -379,7 +379,7 @@ public List<A> toList() {
      *         <code>None</code>.
      */
     public Option<A> toOption() {
-      return isLeft() ? some(value()) : Option.<A>none();
+      return isLeft() ? some(value()) : Option.none();
     }
 
     /**
@@ -402,7 +402,7 @@ public Array<A> toArray() {
      * @return A single element stream if this projection has a value, otherwise an empty stream.
      */
     public Stream<A> toStream() {
-      return isLeft() ? Stream.single(value()) : Stream.<A>nil();
+      return isLeft() ? Stream.single(value()) : Stream.nil();
     }
 
     /**
@@ -417,13 +417,13 @@ public Collection<A> toCollection() {
    public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
        return isLeft() ?
                f.f(value()).map(Either::<C, B>left) :
-               some(Either.<C, B>right(e.right().value()));
+               some(Either.right(e.right().value()));
    }
 
   public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
       return isLeft() ?
               f.f(value()).map(Either::<C, B>left) :
-              Stream.single(Either.<C, B>right(e.right().value()));
+              Stream.single(Either.right(e.right().value()));
   }
   }
 
@@ -551,7 +551,7 @@ public <X> Either<A, X> bind(final F<B, Either<A, X>> f) {
      * @return An either after binding through this projection.
      */
     public <X> Either<A, X> sequence(final Either<A, X> e) {
-      return bind(Function.<B, Either<A, X>>constant(e));
+      return bind(Function.constant(e));
     }
     /**
        * Traverse with function that produces List (non-determinism).
@@ -562,7 +562,7 @@ public <X> Either<A, X> sequence(final Either<A, X> e) {
       public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
           return isRight() ?
                   f.f(value()).map(Either::right) :
-                  list(Either.<A, C>left(e.left().value()));
+                  list(Either.left(e.left().value()));
       }
 
       /**
@@ -574,19 +574,19 @@ public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
       public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
           return isRight() ?
                   IOFunctions.map(f.f(value()), Either::<A, C>right) :
-                  IOFunctions.lazy(() -> Either.<A, C>left(e.left().value()));
+                  IOFunctions.lazy(() -> Either.left(e.left().value()));
       }
 
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
           return isRight() ?
                   f.f(value()).map(Either::<A, C>right) :
-                  p(Either.<A, C>left(e.left().value()));
+                  p(Either.left(e.left().value()));
       }
 
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
           return isRight() ?
                   f.f(value()).map(Either::<A, C>right) :
-                  some(Either.<A, C>left(e.left().value()));
+                  some(Either.left(e.left().value()));
       }
 
     /**
@@ -600,9 +600,9 @@ public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
     public <X> Option<Either<X, B>> filter(final F<B, Boolean> f) {
       return isRight() ?
              f.f(value()) ?
-             Option.<Either<X, B>>some(new Right<X, B>(value())) :
-             Option.<Either<X, B>>none() :
-             Option.<Either<X, B>>none();
+             Option.some(new Right<X, B>(value())) :
+             Option.none() :
+             Option.none();
     }
 
     /**
@@ -645,7 +645,7 @@ public boolean exists(final F<B, Boolean> f) {
      * @return A single element list if this projection has a value, otherwise an empty list.
      */
     public List<B> toList() {
-      return isRight() ? single(value()) : List.<B>nil();
+      return isRight() ? single(value()) : List.nil();
     }
 
     /**
@@ -656,7 +656,7 @@ public List<B> toList() {
      *         <code>None</code>.
      */
     public Option<B> toOption() {
-      return isRight() ? some(value()) : Option.<B>none();
+      return isRight() ? some(value()) : Option.none();
     }
 
     /**
@@ -679,7 +679,7 @@ public Array<B> toArray() {
      * @return A single element stream if this projection has a value, otherwise an empty stream.
      */
     public Stream<B> toStream() {
-      return isRight() ? Stream.single(value()) : Stream.<B>nil();
+      return isRight() ? Stream.single(value()) : Stream.nil();
     }
 
     /**
@@ -694,7 +694,7 @@ public Collection<B> toCollection() {
       public <C> Stream<Either<A, C>> traverseStream(F<B, Stream<C>> f) {
           return isRight() ?
                   f.f(value()).map(Either::right) :
-                  Stream.<Either<A,C>>single(left(e.left().value()));
+                  Stream.single(left(e.left().value()));
 
       }
   }
@@ -706,7 +706,7 @@ public <C> Stream<Either<A, C>> traverseStream(F<B, Stream<C>> f) {
    * @return A left value of either.
    */
   public static <A, B> Either<A, B> left(final A a) {
-    return new Left<A, B>(a);
+    return new Left<>(a);
   }
 
   /**
@@ -734,7 +734,7 @@ public static <A, B> F<B, Either<A, B>> right_() {
    * @return A right value of either.
    */
   public static <A, B> Either<A, B> right(final B b) {
-    return new Right<A, B>(b);
+    return new Right<>(b);
   }
 
   /**
@@ -781,7 +781,7 @@ public static <A, B> Either<A, B> joinRight(final Either<A, Either<A, B>> e) {
    */
   public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a) {
     return a.isEmpty() ?
-           Either.<List<A>, X>left(List.<A>nil()) :
+           Either.left(List.nil()) :
            a.head().left().bind(aa -> sequenceLeft(a.tail()).left().map(cons_(aa)));
   }
 
@@ -793,7 +793,7 @@ public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a)
    */
   public static <B, X> Either<X, List<B>> sequenceRight(final List<Either<X, B>> a) {
     return a.isEmpty() ?
-           Either.<X, List<B>>right(List.<B>nil()) :
+           Either.right(List.nil()) :
            a.head().right().bind(bb -> sequenceRight(a.tail()).right().map(cons_(bb)));
   }
 
@@ -803,7 +803,7 @@ public static <B, X> Either<X, List<B>> sequenceRight(final List<Either<X, B>> a
    * @return traversed value
    */
   public <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
-    return right().<C>traverseList(f);
+    return right().traverseList(f);
   }
 
   /**
@@ -812,7 +812,7 @@ public <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
      * @return traversed value
   */
     public <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
-        return left().<C>traverseList(f);
+        return left().traverseList(f);
     }
 
   /**
@@ -821,7 +821,7 @@ public <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
    * @return traversed value
    */
   public <C> IO<Either<A, C>> traverseIORight(final F<B, IO<C>> f) {
-    return right().<C>traverseIO(f);
+    return right().traverseIO(f);
   }
 
   /**
@@ -830,7 +830,7 @@ public <C> IO<Either<A, C>> traverseIORight(final F<B, IO<C>> f) {
    * @return traversed value
    */
   public <C> IO<Either<C, B>> traverseIOLeft(final F<A, IO<C>> f) {
-    return left().<C>traverseIO(f);
+    return left().traverseIO(f);
   }
 
   /**
@@ -839,7 +839,7 @@ public <C> IO<Either<C, B>> traverseIOLeft(final F<A, IO<C>> f) {
    * @return traversed value
    */
   public <C> Option<Either<A, C>> traverseOptionRight(final F<B, Option<C>> f) {
-    return right().<C>traverseOption(f);
+    return right().traverseOption(f);
   }
 
   /**
@@ -848,7 +848,7 @@ public <C> Option<Either<A, C>> traverseOptionRight(final F<B, Option<C>> f) {
    * @return traversed value
    */
   public <C> Option<Either<C, B>> traverseOptionLeft(final F<A, Option<C>> f) {
-    return left().<C>traverseOption(f);
+    return left().traverseOption(f);
   }
 
   /**
@@ -857,7 +857,7 @@ public <C> Option<Either<C, B>> traverseOptionLeft(final F<A, Option<C>> f) {
    * @return traversed value
    */
   public <C> Stream<Either<A, C>> traverseStreamRight(final F<B, Stream<C>> f) {
-    return right().<C>traverseStream(f);
+    return right().traverseStream(f);
   }
 
   /**
@@ -866,7 +866,7 @@ public <C> Stream<Either<A, C>> traverseStreamRight(final F<B, Stream<C>> f) {
    * @return traversed value
    */
   public <C> Stream<Either<C, B>> traverseStreamLeft(final F<A, Stream<C>> f) {
-    return left().<C>traverseStream(f);
+    return left().traverseStream(f);
   }
 
 
@@ -890,7 +890,7 @@ public static <A> A reduce(final Either<A, A> e) {
    * @return A constructed either based on the given condition.
    */
   public static <A, B> Either<A, B> iif(final boolean c, final F0<B> right, final F0<A> left) {
-    return c ? new Right<A, B>(right.f()) : new Left<A, B>(left.f());
+    return c ? new Right<>(right.f()) : new Left<>(left.f());
   }
 
   /**
@@ -900,7 +900,7 @@ public static <A, B> Either<A, B> iif(final boolean c, final F0<B> right, final
    * @return All the left values in the given list.
    */
   public static <A, B> List<A> lefts(final List<Either<A, B>> es) {
-    return es.foldRight(e -> as -> e.isLeft() ? as.cons(e.left().value()) : as, List.<A>nil());
+    return es.foldRight(e -> as -> e.isLeft() ? as.cons(e.left().value()) : as, List.nil());
   }
 
   /**
@@ -910,7 +910,7 @@ public static <A, B> List<A> lefts(final List<Either<A, B>> es) {
    * @return All the right values in the given list.
    */
   public static <A, B> List<B> rights(final List<Either<A, B>> es) {
-    return es.foldRight(e -> bs -> e.isRight() ? bs.cons(e.right().value()) : bs, List.<B>nil());
+    return es.foldRight(e -> bs -> e.isRight() ? bs.cons(e.right().value()) : bs, List.nil());
   }
 
     public String toString() {
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index b7533ffd..1666d7b2 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -220,7 +220,7 @@ public Enumerator<A> setMax(final Option<A> max) {
   public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, final F<A, Option<A>> predecessor,
                                              final Option<A> max, final Option<A> min, final Ord<A> order,
                                              final F<A, F<Long, Option<A>>> plus) {
-    return new Enumerator<A>(successor, predecessor, max, min, order, plus);
+    return new Enumerator<>(successor, predecessor, max, min, order, plus);
   }
 
   /**
@@ -236,30 +236,30 @@ public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, fina
    */
   public static <A> Enumerator<A> enumerator(final F<A, Option<A>> successor, final F<A, Option<A>> predecessor,
                                              final Option<A> max, final Option<A> min, final Ord<A> order) {
-    return new Enumerator<A>(successor, predecessor, max, min, order, curry((a, l) -> {
-        if (l == 0L)
-          return some(a);
-        else if (l < 0L) {
-          A aa = a;
-          for (long x = l; x < 0; x++) {
-            final Option<A> s = predecessor.f(aa);
-            if (s.isNone())
-              return none();
-            else
-              aa = s.some();
-          }
-          return some(aa);
-        } else {
-          A aa = a;
-          for (long x = l; x > 0; x--) {
-            final Option<A> s = successor.f(aa);
-            if (s.isNone())
-              return none();
-            else
-              aa = s.some();
-          }
-          return some(aa);
+    return new Enumerator<>(successor, predecessor, max, min, order, curry((a, l) -> {
+      if (l == 0L)
+        return some(a);
+      else if (l < 0L) {
+        A aa = a;
+        for (long x = l; x < 0; x++) {
+          final Option<A> s = predecessor.f(aa);
+          if (s.isNone())
+            return none();
+          else
+            aa = s.some();
         }
+        return some(aa);
+      } else {
+        A aa = a;
+        for (long x = l; x > 0; x--) {
+          final Option<A> s = successor.f(aa);
+          if (s.isNone())
+            return none();
+          else
+            aa = s.some();
+        }
+        return some(aa);
+      }
     }));
   }
 
@@ -267,8 +267,8 @@ else if (l < 0L) {
    * An enumerator for <code>boolean</code>.
    */
   public static final Enumerator<Boolean> booleanEnumerator = enumerator(
-      b -> b ? Option.<Boolean>none() : some(true),
-      b -> b ? some(false) : Option.<Boolean>none(),
+      b -> b ? Option.none() : some(true),
+      b -> b ? some(false) : Option.none(),
       some(true), some(false), booleanOrd
   );
 
@@ -276,8 +276,8 @@ else if (l < 0L) {
    * An enumerator for <code>byte</code>.
    */
   public static final Enumerator<Byte> byteEnumerator = enumerator(
-      b -> b == Byte.MAX_VALUE ? Option.<Byte>none() : some((byte) (b + 1)),
-      b -> b == Byte.MIN_VALUE ? Option.<Byte>none() : some((byte) (b - 1)),
+      b -> b == Byte.MAX_VALUE ? Option.none() : some((byte) (b + 1)),
+      b -> b == Byte.MIN_VALUE ? Option.none() : some((byte) (b - 1)),
       some(Byte.MAX_VALUE), some(Byte.MIN_VALUE), byteOrd
   );
 
@@ -285,8 +285,8 @@ else if (l < 0L) {
    * An enumerator for <code>char</code>.
    */
   public static final Enumerator<Character> charEnumerator = enumerator(
-      c -> c == Character.MAX_VALUE ? Option.<Character>none() : some((char) (c + 1)),
-      c -> c == Character.MIN_VALUE ? Option.<Character>none() : some((char) (c - 1)),
+      c -> c == Character.MAX_VALUE ? Option.none() : some((char) (c + 1)),
+      c -> c == Character.MIN_VALUE ? Option.none() : some((char) (c - 1)),
       some(Character.MAX_VALUE), some(Character.MIN_VALUE), charOrd
   );
 
@@ -294,8 +294,8 @@ else if (l < 0L) {
    * An enumerator for <code>double</code>.
    */
   public static final Enumerator<Double> doubleEnumerator = enumerator(
-      d -> d == Double.MAX_VALUE ? Option.<Double>none() : some(d + 1D),
-      d -> d == Double.MIN_VALUE ? Option.<Double>none() : some(d - 1D),
+      d -> d == Double.MAX_VALUE ? Option.none() : some(d + 1D),
+      d -> d == Double.MIN_VALUE ? Option.none() : some(d - 1D),
       some(Double.MAX_VALUE), some(Double.MIN_VALUE), doubleOrd
   );
 
@@ -303,8 +303,8 @@ else if (l < 0L) {
    * An enumerator for <code>float</code>.
    */
   public static final Enumerator<Float> floatEnumerator = enumerator(
-      f -> f == Float.MAX_VALUE ? Option.<Float>none() : some(f + 1F),
-      f -> f == Float.MIN_VALUE ? Option.<Float>none() : some(f - 1F),
+      f -> f == Float.MAX_VALUE ? Option.none() : some(f + 1F),
+      f -> f == Float.MIN_VALUE ? Option.none() : some(f - 1F),
       some(Float.MAX_VALUE), some(Float.MIN_VALUE), floatOrd
   );
 
@@ -312,8 +312,8 @@ else if (l < 0L) {
    * An enumerator for <code>int</code>.
    */
   public static final Enumerator<Integer> intEnumerator = enumerator(
-      i -> i == Integer.MAX_VALUE ? Option.<Integer>none() : some(i + 1),
-      i -> i == Integer.MIN_VALUE ? Option.<Integer>none() : some(i - 1),
+      i -> i == Integer.MAX_VALUE ? Option.none() : some(i + 1),
+      i -> i == Integer.MIN_VALUE ? Option.none() : some(i - 1),
       some(Integer.MAX_VALUE), some(Integer.MIN_VALUE), intOrd
   );
 
@@ -323,7 +323,7 @@ else if (l < 0L) {
   public static final Enumerator<BigInteger> bigintEnumerator = enumerator(
       i -> some(i.add(BigInteger.ONE)),
       i -> some(i.subtract(BigInteger.ONE)),
-      Option.<BigInteger>none(), Option.<BigInteger>none(), bigintOrd,
+      Option.none(), Option.none(), bigintOrd,
       curry((i, l) -> some(i.add(BigInteger.valueOf(l))))
   );
 
@@ -333,7 +333,7 @@ else if (l < 0L) {
   public static final Enumerator<BigDecimal> bigdecimalEnumerator = enumerator(
       i -> some(i.add(BigDecimal.ONE)),
       i -> some(i.subtract(BigDecimal.ONE)),
-      Option.<BigDecimal>none(), Option.<BigDecimal>none(), bigdecimalOrd,
+      Option.none(), Option.none(), bigdecimalOrd,
       curry((d, l) -> some(d.add(BigDecimal.valueOf(l))))
   );
 
@@ -341,8 +341,8 @@ else if (l < 0L) {
    * An enumerator for <code>long</code>.
    */
   public static final Enumerator<Long> longEnumerator = enumerator(
-      i -> i == Long.MAX_VALUE ? Option.<Long>none() : some(i + 1L),
-      i -> i == Long.MIN_VALUE ? Option.<Long>none() : some(i - 1L),
+      i -> i == Long.MAX_VALUE ? Option.none() : some(i + 1L),
+      i -> i == Long.MIN_VALUE ? Option.none() : some(i - 1L),
       some(Long.MAX_VALUE), some(Long.MIN_VALUE), longOrd
   );
 
@@ -350,8 +350,8 @@ else if (l < 0L) {
    * An enumerator for <code>short</code>.
    */
   public static final Enumerator<Short> shortEnumerator = enumerator(
-      i -> i == Short.MAX_VALUE ? Option.<Short>none() : some((short) (i + 1)),
-      i -> i == Short.MIN_VALUE ? Option.<Short>none() : some((short) (i - 1)),
+      i -> i == Short.MAX_VALUE ? Option.none() : some((short) (i + 1)),
+      i -> i == Short.MIN_VALUE ? Option.none() : some((short) (i - 1)),
       some(Short.MAX_VALUE), some(Short.MIN_VALUE), shortOrd
   );
 
@@ -359,8 +359,8 @@ else if (l < 0L) {
    * An enumerator for <code>Ordering</code>.
    */
   public static final Enumerator<Ordering> orderingEnumerator = enumerator(
-      o -> o == LT ? some(EQ) : o == EQ ? some(GT) : Option.<Ordering>none(),
-      o -> o == GT ? some(EQ) : o == EQ ? some(LT) : Option.<Ordering>none(),
+      o -> o == LT ? some(EQ) : o == EQ ? some(GT) : Option.none(),
+      o -> o == GT ? some(EQ) : o == EQ ? some(LT) : Option.none(),
       some(GT), some(LT), orderingOrd
   );
 
@@ -370,7 +370,7 @@ else if (l < 0L) {
   public static final Enumerator<Natural> naturalEnumerator = enumerator(
       n -> some(n.succ()),
       Natural::pred,
-      Option.<Natural>none(), some(Natural.ZERO), naturalOrd,
+      Option.none(), some(Natural.ZERO), naturalOrd,
       curry((n, l) ->
         some(n).apply(
           Natural.natural(l).map(curry((n1, n2) -> n1.add(n2)))
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index 6b03a96a..9a145b37 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -63,7 +63,7 @@ public Iterator<K> iterator() {
    * @param h The hashing strategy.
    */
   public HashMap(final Equal<K> e, final Hash<K> h) {
-    m = new java.util.HashMap<Key<K>, V>();
+    m = new java.util.HashMap<>();
     this.e = e;
     this.h = h;
   }
@@ -83,13 +83,13 @@ public HashMap(java.util.Map<K, V> map, final Equal<K> e, final Hash<K> h) {
    * @param initialCapacity The initial capacity.
    */
   public HashMap(final Equal<K> e, final Hash<K> h, final int initialCapacity) {
-    m = new java.util.HashMap<Key<K>, V>(initialCapacity);
+    m = new java.util.HashMap<>(initialCapacity);
     this.e = e;
     this.h = h;
   }
 
     public HashMap(java.util.Map<K, V> map) {
-        this(map, Equal.<K>anyEqual(), Hash.<K>anyHash());
+        this(map, Equal.anyEqual(), Hash.anyHash());
     }
 
     /**
@@ -101,7 +101,7 @@ public HashMap(java.util.Map<K, V> map) {
    * @param loadFactor      The load factor.
    */
   public HashMap(final Equal<K> e, final Hash<K> h, final int initialCapacity, final float loadFactor) {
-    m = new java.util.HashMap<Key<K>, V>(initialCapacity, loadFactor);
+    m = new java.util.HashMap<>(initialCapacity, loadFactor);
     this.e = e;
     this.h = h;
   }
@@ -121,7 +121,7 @@ public static <K, V> HashMap<K, V> hashMap() {
    * @return A new hash map.
    */
   public static <K, V> HashMap<K, V> hashMap(final Equal<K> e, final Hash<K> h) {
-    return new HashMap<K, V>(e, h);
+    return new HashMap<>(e, h);
   }
 
   /**
@@ -152,7 +152,7 @@ public int hash(final K k) {
    * @return A potential value for the given key.
    */
   public Option<V> get(final K k) {
-    return fromNull(m.get(new Key<K>(k, e, h)));
+    return fromNull(m.get(new Key<>(k, e, h)));
   }
 
   /**
@@ -178,7 +178,7 @@ public void clear() {
    * @return <code>true</code> if this hash map contains the given key, <code>false</code> otherwise.
    */
   public boolean contains(final K k) {
-    return m.containsKey(new Key<K>(k, e, h));
+    return m.containsKey(new Key<>(k, e, h));
   }
 
   /**
@@ -187,7 +187,7 @@ public boolean contains(final K k) {
    * @return All key entries in this hash map.
    */
   public List<K> keys() {
-    final List.Buffer<K> b = new List.Buffer<K>();
+    final List.Buffer<K> b = new List.Buffer<>();
 
     for (final Key<K> k : m.keySet()) {
       b.snoc(k.k());
@@ -202,7 +202,7 @@ public List<K> keys() {
    * @return All values in this hash map.
    */
   public List<V> values() {
-    return keys().map(k -> m.get(new Key<K>(k, e, h)));
+    return keys().map(k -> m.get(new Key<>(k, e, h)));
   }
 
   /**
@@ -231,7 +231,7 @@ public int size() {
    */
   public void set(final K k, final V v) {
     if (v != null) {
-        m.put(new Key<K>(k, e, h), v);
+        m.put(new Key<>(k, e, h), v);
     }
   }
 
@@ -241,7 +241,7 @@ public void set(final K k, final V v) {
    * @param k The key to delete from this hash map.
    */
   public void delete(final K k) {
-    m.remove(new Key<K>(k, e, h));
+    m.remove(new Key<>(k, e, h));
   }
 
   /**
@@ -251,13 +251,13 @@ public void delete(final K k) {
    * @return The value that was associated with the given key, if there was one.
    */
   public Option<V> getDelete(final K k) {
-    return fromNull(m.remove(new Key<K>(k, e, h)));
+    return fromNull(m.remove(new Key<>(k, e, h)));
   }
 
   public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
                                   F<V, B> valueFunction,
                                   Equal<A> equal, Hash<A> hash) {
-    final HashMap<A, B> hashMap = new HashMap<A, B>(equal, hash);
+    final HashMap<A, B> hashMap = new HashMap<>(equal, hash);
     for (K key : keys()) {
       final A newKey = keyFunction.f(key);
       final B newValue = valueFunction.f(get(key).some());
@@ -268,7 +268,7 @@ public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
 
   public <A, B> HashMap<A, B> map(F<K, A> keyFunction,
                                   F<V, B> valueFunction) {
-    return map(keyFunction, valueFunction, Equal.<A>anyEqual(), Hash.<A>anyHash());
+    return map(keyFunction, valueFunction, Equal.anyEqual(), Hash.anyHash());
   }
 
   public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function, Equal<A> equal, Hash<A> hash) {
@@ -280,15 +280,15 @@ public <A, B> HashMap<A, B> map(F<P2<K, V>, P2<A, B>> function) {
   }
 
   public <A> HashMap<A, V> mapKeys(F<K, A> keyFunction, Equal<A> equal, Hash<A> hash) {
-    return map(keyFunction, Function.<V>identity(), equal, hash);
+    return map(keyFunction, Function.identity(), equal, hash);
   }
 
   public <A> HashMap<A, V> mapKeys(F<K, A> function) {
-    return mapKeys(function, Equal.<A>anyEqual(), Hash.<A>anyHash());
+    return mapKeys(function, Equal.anyEqual(), Hash.anyHash());
   }
 
   public <B> HashMap<K, B> mapValues(F<V, B> function) {
-    return map(Function.<K>identity(), function, e, h);
+    return map(Function.identity(), function, e, h);
   }
 
   public void foreachDoEffect(Effect1<P2<K, V>> effect) {
@@ -325,7 +325,7 @@ public Array<P2<K, V>> toArray() {
   }
 
   public java.util.Map<K, V> toMap() {
-    final java.util.HashMap<K,V> result = new java.util.HashMap<K, V>();
+    final java.util.HashMap<K,V> result = new java.util.HashMap<>();
     for (K key : keys()) {
       result.put(key, get(key).some());
     }
@@ -368,7 +368,7 @@ public static <K, V> HashMap<K, V> from(final Iterable<P2<K, V>> entries, final
    * Converts the Iterable to a HashMap
    */
   public static <K, V> HashMap<K, V> iterableHashMap(final Equal<K> equal, final Hash<K> hash, final Iterable<P2<K, V>> entries) {
-    final HashMap<K, V> map = new HashMap<K, V>(equal, hash);
+    final HashMap<K, V> map = new HashMap<>(equal, hash);
     for (P2<K, V> entry : entries) {
       map.set(entry._1(), entry._2());
     }
@@ -379,7 +379,7 @@ public static <K, V> HashMap<K, V> iterableHashMap(final Equal<K> equal, final H
    * Converts the Iterable to a HashMap
    */
   public static <K, V> HashMap<K, V> iterableHashMap(final Iterable<P2<K, V>> entries) {
-    return iterableHashMap(Equal.<K>anyEqual(), Hash.<K>anyHash(), entries);
+    return iterableHashMap(Equal.anyEqual(), Hash.anyHash(), entries);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/HashSet.java b/core/src/main/java/fj/data/HashSet.java
index 1c6868e3..d7b2c832 100644
--- a/core/src/main/java/fj/data/HashSet.java
+++ b/core/src/main/java/fj/data/HashSet.java
@@ -36,7 +36,7 @@ public Iterator<A> iterator() {
    * @param h The hashing strategy.
    */
   public HashSet(final Equal<A> e, final Hash<A> h) {
-    m = new HashMap<A, Unit>(e, h);
+    m = new HashMap<>(e, h);
   }
 
   /**
@@ -47,7 +47,7 @@ public HashSet(final Equal<A> e, final Hash<A> h) {
    * @param initialCapacity The initial capacity.
    */
   public HashSet(final Equal<A> e, final Hash<A> h, final int initialCapacity) {
-    m = new HashMap<A, Unit>(e, h, initialCapacity);
+    m = new HashMap<>(e, h, initialCapacity);
   }
 
   /**
@@ -59,7 +59,7 @@ public HashSet(final Equal<A> e, final Hash<A> h, final int initialCapacity) {
    * @param loadFactor      The load factor.
    */
   public HashSet(final Equal<A> e, final Hash<A> h, final int initialCapacity, final float loadFactor) {
-    m = new HashMap<A, Unit>(e, h, initialCapacity, loadFactor);
+    m = new HashMap<>(e, h, initialCapacity, loadFactor);
   }
 
   /**
@@ -87,7 +87,7 @@ public int hash(final A a) {
    * Creates a new HashSet using the given Equal and Hash
    */
   public static <A> HashSet<A> empty(final Equal<A> e, final Hash<A> h) {
-    return new HashSet<A>(e, h);
+    return new HashSet<>(e, h);
   }
 
   /**
@@ -230,7 +230,7 @@ public java.util.List<A> toJavaList() {
   }
 
   public java.util.Set<A> toJavaSet() {
-    return new java.util.HashSet<A>(toCollection());
+    return new java.util.HashSet<>(toCollection());
   }
 
   public static <A> HashSet<A> fromSet(java.util.Set<A> s) {
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index c3d5fe01..cfe5eba2 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -94,8 +94,8 @@ public static IO<Unit> closeReader(final Reader r) {
      */
     public static <A> IO<IterV<String, A>> enumFileLines(final File f, final Option<Charset> encoding, final IterV<String, A> i) {
         return bracket(bufferedReader(f, encoding)
-                , Function.<BufferedReader, IO<Unit>>vary(closeReader)
-                , partialApply2(IOFunctions.<A>lineReader(), i));
+                , Function.vary(closeReader)
+                , partialApply2(IOFunctions.lineReader(), i));
     }
 
     /**
@@ -107,8 +107,8 @@ public static <A> IO<IterV<String, A>> enumFileLines(final File f, final Option<
      */
     public static <A> IO<IterV<char[], A>> enumFileCharChunks(final File f, final Option<Charset> encoding, final IterV<char[], A> i) {
         return bracket(fileReader(f, encoding)
-                , Function.<Reader, IO<Unit>>vary(closeReader)
-                , partialApply2(IOFunctions.<A>charChunkReader(), i));
+                , Function.vary(closeReader)
+                , partialApply2(IOFunctions.charChunkReader(), i));
     }
 
     /**
@@ -120,8 +120,8 @@ public static <A> IO<IterV<char[], A>> enumFileCharChunks(final File f, final Op
      */
     public static <A> IO<IterV<Character, A>> enumFileChars(final File f, final Option<Charset> encoding, final IterV<Character, A> i) {
         return bracket(fileReader(f, encoding)
-                , Function.<Reader, IO<Unit>>vary(closeReader)
-                , partialApply2(IOFunctions.<A>charChunkReader2(), i));
+                , Function.vary(closeReader)
+                , partialApply2(IOFunctions.charChunkReader2(), i));
     }
 
     public static IO<BufferedReader> bufferedReader(final File f, final Option<Charset> encoding) {
@@ -194,8 +194,8 @@ public IO<IterV<String, A>> f(final IterV<String, A> it) {
                         if (s == null) {
                             return i;
                         }
-                        final Input<String> input = Input.<String>el(s);
-                        final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.<Input<String>, IterV<String, A>>apply(input));
+                        final Input<String> input = Input.el(s);
+                        final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.apply(input));
                         i = i.fold(done, cont)._1();
                     }
                     return i;
@@ -238,9 +238,9 @@ public IO<IterV<char[], A>> f(final IterV<char[], A> it) {
                         if (numRead < buffer.length) {
                             buffer = Arrays.copyOfRange(buffer, 0, numRead);
                         }
-                        final Input<char[]> input = Input.<char[]>el(buffer);
+                        final Input<char[]> input = Input.el(buffer);
                         final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
-                                F1Functions.lazy(Function.<Input<char[]>, IterV<char[], A>>apply(input));
+                                F1Functions.lazy(Function.apply(input));
                         i = i.fold(done, cont)._1();
                     }
                     return i;
@@ -286,7 +286,7 @@ public IO<IterV<Character, A>> f(final IterV<Character, A> it) {
                         for (int c = 0; c < buffer.length; c++) {
                             final Input<Character> input = Input.el(buffer[c]);
                             final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
-                                    Function.<Input<Character>, IterV<Character, A>>apply(input);
+                                    Function.apply(input);
                             i = i.fold(done, cont);
                         }
                     }
@@ -326,14 +326,14 @@ public static IO<Unit> unless(final Boolean b, final IO<Unit> io) {
     public static <A> IO<List<A>> sequence(List<IO<A>> list) {
         F2<IO<A>, IO<List<A>>, IO<List<A>>> f2 = (io, ioList) ->
                 bind(ioList, (xs) -> map(io, x -> List.cons(x, xs)));
-        return list.foldRight(f2, unit(List.<A>nil()));
+        return list.foldRight(f2, unit(List.nil()));
     }
 
 
     public static <A> IO<Stream<A>> sequence(Stream<IO<A>> stream) {
         F2<IO<Stream<A>>, IO<A>, IO<Stream<A>>> f2 = (ioList, io) ->
                 bind(ioList, (xs) -> map(io, x -> Stream.cons(x, () -> xs)));
-        return stream.foldLeft(f2, unit(Stream.<A>nil()));
+        return stream.foldLeft(f2, unit(Stream.nil()));
     }
 
 
@@ -380,7 +380,7 @@ public static <A> IO<Stream<A>> sequenceWhileEager(final Stream<IO<A>> stream, f
         return () -> {
             boolean loop = true;
             Stream<IO<A>> input = stream;
-            Stream<A> result = Stream.<A>nil();
+            Stream<A> result = Stream.nil();
             while (loop) {
                 if (input.isEmpty()) {
                     loop = false;
@@ -453,8 +453,8 @@ public static IO<Unit> stdoutPrint(final String s) {
     }
 
     public static IO<LazyString> getContents() {
-        Stream<IO<Integer>> s = Stream.<IO<Integer>>repeat(() -> (int) stdinBufferedReader.read());
-        return map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.<Character>map(i -> (char) i.intValue())));
+        Stream<IO<Integer>> s = Stream.repeat(() -> stdinBufferedReader.read());
+        return map(sequenceWhile(s, i -> i != -1), s2 -> LazyString.fromStream(s2.map(i -> (char) i.intValue())));
     }
 
     public static IO<Unit> interact(F<LazyString, LazyString> f) {
diff --git a/core/src/main/java/fj/data/IterableW.java b/core/src/main/java/fj/data/IterableW.java
index 0633ffd4..db75dbb5 100644
--- a/core/src/main/java/fj/data/IterableW.java
+++ b/core/src/main/java/fj/data/IterableW.java
@@ -33,7 +33,7 @@ private IterableW(final Iterable<A> i) {
    * @return An iterable equipped with some useful functions.
    */
   public static <A> IterableW<A> wrap(final Iterable<A> a) {
-    return new IterableW<A>(a);
+    return new IterableW<>(a);
   }
 
   /**
@@ -128,9 +128,9 @@ public static <A, B, C> F<Iterable<A>, F<Iterable<B>, IterableW<C>>> liftM2(fina
   public static <A, T extends Iterable<A>> IterableW<IterableW<A>> sequence(final Iterable<T> as) {
     final Stream<T> ts = iterableStream(as);
     return ts.isEmpty() ?
-        iterable(wrap(Option.<A>none())) :
+        iterable(wrap(Option.none())) :
         wrap(ts.head()).bind(a ->
-            sequence(ts.tail().map(IterableW.<T, Stream<T>>wrap())._1()).bind(as2 ->
+            sequence(ts.tail().map(IterableW.wrap())._1()).bind(as2 ->
                 iterable(wrap(Stream.cons(a, () -> iterableStream(as2))))
             )
         );
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index 391c4087..bcb03cc0 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -82,17 +82,17 @@ public <Z> Z fold(final F<P2<A, Input<E>>, Z> done, final F<F<Input<E>, IterV<E,
     public final A run() {
       final F<IterV<E, A>, Option<A>> runCont =
         new F<IterV<E, A>, Option<A>>() {
-          final F<P2<A, Input<E>>, Option<A>> done = F1Functions.andThen(P2.<A, Input<E>>__1(), Option.<A>some_());
-          final F<F<Input<E>, IterV<E, A>>, Option<A>> cont = Function.constant(Option.<A>none());
+          final F<P2<A, Input<E>>, Option<A>> done = F1Functions.andThen(P2.__1(), Option.some_());
+          final F<F<Input<E>, IterV<E, A>>, Option<A>> cont = Function.constant(Option.none());
 
           @Override
           public Option<A> f(final IterV<E, A> i) {
             return i.fold(done, cont);
           }
         };
-      final F<P2<A, Input<E>>, A> done = P2.<A, Input<E>>__1();
+      final F<P2<A, Input<E>>, A> done = P2.__1();
       final F<F<Input<E>, IterV<E, A>>, A> cont =
-              k -> runCont.f(k.f(Input.<E>eof())).valueE("diverging iteratee");
+              k -> runCont.f(k.f(Input.eof())).valueE("diverging iteratee");
       return fold(done, cont);
     }
 
@@ -154,7 +154,7 @@ public IterV<E, Unit> f(final Input<E> s) {
           }
         };
       return n == 0
-        ? done(Unit.unit(), Input.<E>empty())
+        ? done(Unit.unit(), Input.empty())
         : cont(step);
     }
 
@@ -166,7 +166,7 @@ public static <E> IterV<E, Option<E>> head() {
 
           final F0<IterV<E, Option<E>>> empty = () -> cont(step);
 
-          final F0<F<E, IterV<E, Option<E>>>> el = () -> e -> done(Option.<E>some(e), Input.<E>empty());
+          final F0<F<E, IterV<E, Option<E>>>> el = () -> e -> done(Option.some(e), Input.<E>empty());
 
           final F0<IterV<E, Option<E>>> eof = () -> done(Option.<E>none(), Input.<E>eof());
 
@@ -186,7 +186,7 @@ public static <E> IterV<E, Option<E>> peek() {
 
           final F0<IterV<E, Option<E>>> empty = () -> cont(step);
 
-          final F0<F<E, IterV<E, Option<E>>>> el = () -> e -> done(Option.<E>some(e), Input.<E>el(e));
+          final F0<F<E, IterV<E, Option<E>>>> el = () -> e -> done(Option.some(e), Input.el(e));
 
           final F0<IterV<E, Option<E>>> eof = () -> done(Option.<E>none(), Input.<E>eof());
 
@@ -216,7 +216,7 @@ public F<Input<E>, IterV<E, List<E>>> f(final List<E> acc) {
               return s -> s.apply(empty, el, eof);
             }
           };
-        return cont(step.f(List.<E> nil()));
+        return cont(step.f(List.nil()));
     }
   }
 
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 0be648f2..b4b6173a 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -51,7 +51,7 @@ private Java() {
    * @return A function that converts lists to array lists.
    */
   public static <A> F<List<A>, ArrayList<A>> List_ArrayList() {
-    return as -> new ArrayList<A>(as.toCollection());
+    return as -> new ArrayList<>(as.toCollection());
   }
 
   /**
@@ -78,7 +78,7 @@ public static <A extends Enum<A>> F<List<A>, EnumSet<A>> List_EnumSet() {
    * @return A function that converts lists to hash sets.
    */
   public static <A> F<List<A>, HashSet<A>> List_HashSet() {
-    return as -> new HashSet<A>(as.toCollection());
+    return as -> new HashSet<>(as.toCollection());
   }
 
   /**
@@ -87,7 +87,7 @@ public static <A> F<List<A>, HashSet<A>> List_HashSet() {
    * @return A function that converts lists to linked hash sets.
    */
   public static <A> F<List<A>, LinkedHashSet<A>> List_LinkedHashSet() {
-    return as -> new LinkedHashSet<A>(as.toCollection());
+    return as -> new LinkedHashSet<>(as.toCollection());
   }
 
   /**
@@ -96,7 +96,7 @@ public static <A> F<List<A>, LinkedHashSet<A>> List_LinkedHashSet() {
    * @return A function that converts lists to linked lists.
    */
   public static <A> F<List<A>, LinkedList<A>> List_LinkedList() {
-    return as -> new LinkedList<A>(as.toCollection());
+    return as -> new LinkedList<>(as.toCollection());
   }
 
   /**
@@ -105,7 +105,7 @@ public static <A> F<List<A>, LinkedList<A>> List_LinkedList() {
    * @return A function that converts lists to priority queues.
    */
   public static <A> F<List<A>, PriorityQueue<A>> List_PriorityQueue() {
-    return as -> new PriorityQueue<A>(as.toCollection());
+    return as -> new PriorityQueue<>(as.toCollection());
   }
 
   /**
@@ -115,7 +115,7 @@ public static <A> F<List<A>, PriorityQueue<A>> List_PriorityQueue() {
    */
   public static <A> F<List<A>, Stack<A>> List_Stack() {
     return as -> {
-      final Stack<A> s = new Stack<A>();
+      final Stack<A> s = new Stack<>();
       s.addAll(as.toCollection());
       return s;
     };
@@ -127,7 +127,7 @@ public static <A> F<List<A>, Stack<A>> List_Stack() {
    * @return A function that converts lists to stacks.
    */
   public static <A> F<List<A>, TreeSet<A>> List_TreeSet() {
-    return as -> new TreeSet<A>(as.toCollection());
+    return as -> new TreeSet<>(as.toCollection());
   }
 
   /**
@@ -136,7 +136,7 @@ public static <A> F<List<A>, TreeSet<A>> List_TreeSet() {
    * @return A function that converts lists to vectors.
    */
   public static <A> F<List<A>, Vector<A>> List_Vector() {
-    return as -> new Vector<A>(as.toCollection());
+    return as -> new Vector<>(as.toCollection());
   }
 
   /**
@@ -146,7 +146,7 @@ public static <A> F<List<A>, Vector<A>> List_Vector() {
    * @return A function that converts lists to array blocking queue.
    */
   public static <A> F<List<A>, ArrayBlockingQueue<A>> List_ArrayBlockingQueue(final boolean fair) {
-    return as -> new ArrayBlockingQueue<A>(as.length(), fair, as.toCollection());
+    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
   }
 
   /**
@@ -155,7 +155,7 @@ public static <A> F<List<A>, ArrayBlockingQueue<A>> List_ArrayBlockingQueue(fina
    * @return A function that converts lists to concurrent linked queues.
    */
   public static <A> F<List<A>, ConcurrentLinkedQueue<A>> List_ConcurrentLinkedQueue() {
-    return as -> new ConcurrentLinkedQueue<A>(as.toCollection());
+    return as -> new ConcurrentLinkedQueue<>(as.toCollection());
   }
 
   /**
@@ -164,7 +164,7 @@ public static <A> F<List<A>, ConcurrentLinkedQueue<A>> List_ConcurrentLinkedQueu
    * @return A function that converts lists to copy on write array lists.
    */
   public static <A> F<List<A>, CopyOnWriteArrayList<A>> List_CopyOnWriteArrayList() {
-    return as -> new CopyOnWriteArrayList<A>(as.toCollection());
+    return as -> new CopyOnWriteArrayList<>(as.toCollection());
   }
 
   /**
@@ -173,7 +173,7 @@ public static <A> F<List<A>, CopyOnWriteArrayList<A>> List_CopyOnWriteArrayList(
    * @return A function that converts lists to copy on write array sets.
    */
   public static <A> F<List<A>, CopyOnWriteArraySet<A>> List_CopyOnWriteArraySet() {
-    return as -> new CopyOnWriteArraySet<A>(as.toCollection());
+    return as -> new CopyOnWriteArraySet<>(as.toCollection());
   }
 
   /**
@@ -182,7 +182,7 @@ public static <A> F<List<A>, CopyOnWriteArraySet<A>> List_CopyOnWriteArraySet()
    * @return A function that converts lists to delay queues.
    */
   public static <A extends Delayed> F<List<A>, DelayQueue<A>> List_DelayQueue() {
-    return as -> new DelayQueue<A>(as.toCollection());
+    return as -> new DelayQueue<>(as.toCollection());
   }
 
   /**
@@ -191,7 +191,7 @@ public static <A extends Delayed> F<List<A>, DelayQueue<A>> List_DelayQueue() {
    * @return A function that converts lists to linked blocking queues.
    */
   public static <A> F<List<A>, LinkedBlockingQueue<A>> List_LinkedBlockingQueue() {
-    return as -> new LinkedBlockingQueue<A>(as.toCollection());
+    return as -> new LinkedBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -200,7 +200,7 @@ public static <A> F<List<A>, LinkedBlockingQueue<A>> List_LinkedBlockingQueue()
    * @return A function that converts lists to priority blocking queues.
    */
   public static <A> F<List<A>, PriorityBlockingQueue<A>> List_PriorityBlockingQueue() {
-    return as -> new PriorityBlockingQueue<A>(as.toCollection());
+    return as -> new PriorityBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -211,7 +211,7 @@ public static <A> F<List<A>, PriorityBlockingQueue<A>> List_PriorityBlockingQueu
    */
   public static <A> F<List<A>, SynchronousQueue<A>> List_SynchronousQueue(final boolean fair) {
     return as -> {
-      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(as.toCollection());
       return q;
     };
@@ -227,7 +227,7 @@ public static <A> F<List<A>, SynchronousQueue<A>> List_SynchronousQueue(final bo
    * @return A function that converts arrays to array lists.
    */
   public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
-    return as -> new ArrayList<A>(as.toCollection());
+    return as -> new ArrayList<>(as.toCollection());
   }
 
   /**
@@ -255,7 +255,7 @@ public static <A extends Enum<A>> F<Array<A>, EnumSet<A>> Array_EnumSet() {
    * @return A function that converts arrays to hash sets.
    */
   public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
-    return as -> new HashSet<A>(as.toCollection());
+    return as -> new HashSet<>(as.toCollection());
   }
 
   /**
@@ -264,7 +264,7 @@ public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
    * @return A function that converts arrays to linked hash sets.
    */
   public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
-    return as -> new LinkedHashSet<A>(as.toCollection());
+    return as -> new LinkedHashSet<>(as.toCollection());
   }
 
   /**
@@ -273,7 +273,7 @@ public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
    * @return A function that converts arrays to linked lists.
    */
   public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
-    return as -> new LinkedList<A>(as.toCollection());
+    return as -> new LinkedList<>(as.toCollection());
   }
 
   /**
@@ -282,7 +282,7 @@ public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
    * @return A function that converts arrays to priority queues.
    */
   public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
-    return as -> new PriorityQueue<A>(as.toCollection());
+    return as -> new PriorityQueue<>(as.toCollection());
   }
 
   /**
@@ -292,7 +292,7 @@ public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
    */
   public static <A> F<Array<A>, Stack<A>> Array_Stack() {
     return as -> {
-      final Stack<A> s = new Stack<A>();
+      final Stack<A> s = new Stack<>();
       s.addAll(as.toCollection());
       return s;
     };
@@ -304,7 +304,7 @@ public static <A> F<Array<A>, Stack<A>> Array_Stack() {
    * @return A function that converts arrays to tree sets.
    */
   public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
-    return as -> new TreeSet<A>(as.toCollection());
+    return as -> new TreeSet<>(as.toCollection());
   }
 
   /**
@@ -313,7 +313,7 @@ public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
    * @return A function that converts arrays to vectors.
    */
   public static <A> F<Array<A>, Vector<A>> Array_Vector() {
-    return as -> new Vector<A>(as.toCollection());
+    return as -> new Vector<>(as.toCollection());
   }
 
   /**
@@ -323,7 +323,7 @@ public static <A> F<Array<A>, Vector<A>> Array_Vector() {
    * @return A function that converts arrays to array blocking queues.
    */
   public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(final boolean fair) {
-    return as -> new ArrayBlockingQueue<A>(as.length(), fair, as.toCollection());
+    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
   }
 
   /**
@@ -332,7 +332,7 @@ public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(fi
    * @return A function that converts arrays to concurrent linked queues.
    */
   public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQueue() {
-    return as -> new ConcurrentLinkedQueue<A>(as.toCollection());
+    return as -> new ConcurrentLinkedQueue<>(as.toCollection());
   }
 
   /**
@@ -341,7 +341,7 @@ public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQu
    * @return A function that converts arrays to copy on write array lists.
    */
   public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayList() {
-    return as -> new CopyOnWriteArrayList<A>(as.toCollection());
+    return as -> new CopyOnWriteArrayList<>(as.toCollection());
   }
 
   /**
@@ -350,7 +350,7 @@ public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayLis
    * @return A function that converts arrays to copy on write array sets.
    */
   public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet() {
-    return as -> new CopyOnWriteArraySet<A>(as.toCollection());
+    return as -> new CopyOnWriteArraySet<>(as.toCollection());
   }
 
   /**
@@ -359,7 +359,7 @@ public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet(
    * @return A function that converts arrays to delay queues.
    */
   public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue() {
-    return as -> new DelayQueue<A>(as.toCollection());
+    return as -> new DelayQueue<>(as.toCollection());
   }
 
   /**
@@ -368,7 +368,7 @@ public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue()
    * @return A function that converts arrays to linked blocking queues.
    */
   public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue() {
-    return as -> new LinkedBlockingQueue<A>(as.toCollection());
+    return as -> new LinkedBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -377,7 +377,7 @@ public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue(
    * @return A function that converts arrays to priority blocking queues.
    */
   public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQueue() {
-    return as -> new PriorityBlockingQueue<A>(as.toCollection());
+    return as -> new PriorityBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -388,7 +388,7 @@ public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQu
    */
   public static <A> F<Array<A>, SynchronousQueue<A>> Array_SynchronousQueue(final boolean fair) {
     return as -> {
-      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(as.toCollection());
       return q;
     };
@@ -433,7 +433,7 @@ public void remove() {
    * @return A function that converts streams to array lists.
    */
   public static <A> F<Stream<A>, ArrayList<A>> Stream_ArrayList() {
-    return as -> new ArrayList<A>(as.toCollection());
+    return as -> new ArrayList<>(as.toCollection());
   }
 
   /**
@@ -460,7 +460,7 @@ public static <A extends Enum<A>> F<Stream<A>, EnumSet<A>> Stream_EnumSet() {
    * @return A function that converts streams to hash sets.
    */
   public static <A> F<Stream<A>, HashSet<A>> Stream_HashSet() {
-    return as -> new HashSet<A>(as.toCollection());
+    return as -> new HashSet<>(as.toCollection());
   }
 
   /**
@@ -469,7 +469,7 @@ public static <A> F<Stream<A>, HashSet<A>> Stream_HashSet() {
    * @return A function that converts streams to linked hash sets.
    */
   public static <A> F<Stream<A>, LinkedHashSet<A>> Stream_LinkedHashSet() {
-    return as -> new LinkedHashSet<A>(as.toCollection());
+    return as -> new LinkedHashSet<>(as.toCollection());
   }
 
   /**
@@ -478,7 +478,7 @@ public static <A> F<Stream<A>, LinkedHashSet<A>> Stream_LinkedHashSet() {
    * @return A function that converts streams to linked lists.
    */
   public static <A> F<Stream<A>, LinkedList<A>> Stream_LinkedList() {
-    return as -> new LinkedList<A>(as.toCollection());
+    return as -> new LinkedList<>(as.toCollection());
   }
 
   /**
@@ -487,7 +487,7 @@ public static <A> F<Stream<A>, LinkedList<A>> Stream_LinkedList() {
    * @return A function that converts streams to priority queues.
    */
   public static <A> F<Stream<A>, PriorityQueue<A>> Stream_PriorityQueue() {
-    return as -> new PriorityQueue<A>(as.toCollection());
+    return as -> new PriorityQueue<>(as.toCollection());
   }
 
   /**
@@ -497,7 +497,7 @@ public static <A> F<Stream<A>, PriorityQueue<A>> Stream_PriorityQueue() {
    */
   public static <A> F<Stream<A>, Stack<A>> Stream_Stack() {
     return as -> {
-      final Stack<A> s = new Stack<A>();
+      final Stack<A> s = new Stack<>();
       s.addAll(as.toCollection());
       return s;
     };
@@ -509,7 +509,7 @@ public static <A> F<Stream<A>, Stack<A>> Stream_Stack() {
    * @return A function that converts streams to tree sets.
    */
   public static <A> F<Stream<A>, TreeSet<A>> Stream_TreeSet() {
-    return as -> new TreeSet<A>(as.toCollection());
+    return as -> new TreeSet<>(as.toCollection());
   }
 
   /**
@@ -518,7 +518,7 @@ public static <A> F<Stream<A>, TreeSet<A>> Stream_TreeSet() {
    * @return A function that converts streams to vectors.
    */
   public static <A> F<Stream<A>, Vector<A>> Stream_Vector() {
-    return as -> new Vector<A>(as.toCollection());
+    return as -> new Vector<>(as.toCollection());
   }
 
   /**
@@ -528,7 +528,7 @@ public static <A> F<Stream<A>, Vector<A>> Stream_Vector() {
    * @return A function that converts streams to array blocking queues.
    */
   public static <A> F<Stream<A>, ArrayBlockingQueue<A>> Stream_ArrayBlockingQueue(final boolean fair) {
-    return as -> new ArrayBlockingQueue<A>(as.length(), fair, as.toCollection());
+    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
   }
 
   /**
@@ -537,7 +537,7 @@ public static <A> F<Stream<A>, ArrayBlockingQueue<A>> Stream_ArrayBlockingQueue(
    * @return A function that converts streams to concurrent linked queues.
    */
   public static <A> F<Stream<A>, ConcurrentLinkedQueue<A>> Stream_ConcurrentLinkedQueue() {
-    return as -> new ConcurrentLinkedQueue<A>(as.toCollection());
+    return as -> new ConcurrentLinkedQueue<>(as.toCollection());
   }
 
   /**
@@ -546,7 +546,7 @@ public static <A> F<Stream<A>, ConcurrentLinkedQueue<A>> Stream_ConcurrentLinked
    * @return A function that converts streams to copy on write array lists.
    */
   public static <A> F<Stream<A>, CopyOnWriteArrayList<A>> Stream_CopyOnWriteArrayList() {
-    return as -> new CopyOnWriteArrayList<A>(as.toCollection());
+    return as -> new CopyOnWriteArrayList<>(as.toCollection());
   }
 
   /**
@@ -555,7 +555,7 @@ public static <A> F<Stream<A>, CopyOnWriteArrayList<A>> Stream_CopyOnWriteArrayL
    * @return A function that converts streams to copy on write array sets.
    */
   public static <A> F<Stream<A>, CopyOnWriteArraySet<A>> Stream_CopyOnWriteArraySet() {
-    return as -> new CopyOnWriteArraySet<A>(as.toCollection());
+    return as -> new CopyOnWriteArraySet<>(as.toCollection());
   }
 
   /**
@@ -564,7 +564,7 @@ public static <A> F<Stream<A>, CopyOnWriteArraySet<A>> Stream_CopyOnWriteArraySe
    * @return A function that converts streams to delay queues.
    */
   public static <A extends Delayed> F<Stream<A>, DelayQueue<A>> Stream_DelayQueue() {
-    return as -> new DelayQueue<A>(as.toCollection());
+    return as -> new DelayQueue<>(as.toCollection());
   }
 
   /**
@@ -573,7 +573,7 @@ public static <A extends Delayed> F<Stream<A>, DelayQueue<A>> Stream_DelayQueue(
    * @return A function that converts streams to linked blocking queues.
    */
   public static <A> F<Stream<A>, LinkedBlockingQueue<A>> Stream_LinkedBlockingQueue() {
-    return as -> new LinkedBlockingQueue<A>(as.toCollection());
+    return as -> new LinkedBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -582,7 +582,7 @@ public static <A> F<Stream<A>, LinkedBlockingQueue<A>> Stream_LinkedBlockingQueu
    * @return A function that converts streams to priority blocking queues.
    */
   public static <A> F<Stream<A>, PriorityBlockingQueue<A>> Stream_PriorityBlockingQueue() {
-    return as -> new PriorityBlockingQueue<A>(as.toCollection());
+    return as -> new PriorityBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -593,7 +593,7 @@ public static <A> F<Stream<A>, PriorityBlockingQueue<A>> Stream_PriorityBlocking
    */
   public static <A> F<Stream<A>, SynchronousQueue<A>> Stream_SynchronousQueue(final boolean fair) {
     return as -> {
-      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(as.toCollection());
       return q;
     };
@@ -609,7 +609,7 @@ public static <A> F<Stream<A>, SynchronousQueue<A>> Stream_SynchronousQueue(fina
    * @return A function that converts options to array lists.
    */
   public static <A> F<Option<A>, ArrayList<A>> Option_ArrayList() {
-    return as -> new ArrayList<A>(as.toCollection());
+    return as -> new ArrayList<>(as.toCollection());
   }
 
   /**
@@ -640,7 +640,7 @@ public static <A extends Enum<A>> F<Option<A>, EnumSet<A>> Option_EnumSet() {
    * @return A function that converts options to hash sets.
    */
   public static <A> F<Option<A>, HashSet<A>> Option_HashSet() {
-    return as -> new HashSet<A>(as.toCollection());
+    return as -> new HashSet<>(as.toCollection());
   }
 
   /**
@@ -649,7 +649,7 @@ public static <A> F<Option<A>, HashSet<A>> Option_HashSet() {
    * @return A function that converts options to linked hash sets.
    */
   public static <A> F<Option<A>, LinkedHashSet<A>> Option_LinkedHashSet() {
-    return as -> new LinkedHashSet<A>(as.toCollection());
+    return as -> new LinkedHashSet<>(as.toCollection());
   }
 
   /**
@@ -658,7 +658,7 @@ public static <A> F<Option<A>, LinkedHashSet<A>> Option_LinkedHashSet() {
    * @return A function that converts options to linked lists.
    */
   public static <A> F<Option<A>, LinkedList<A>> Option_LinkedList() {
-    return as -> new LinkedList<A>(as.toCollection());
+    return as -> new LinkedList<>(as.toCollection());
   }
 
   /**
@@ -667,7 +667,7 @@ public static <A> F<Option<A>, LinkedList<A>> Option_LinkedList() {
    * @return A function that converts options to priority queues.
    */
   public static <A> F<Option<A>, PriorityQueue<A>> Option_PriorityQueue() {
-    return as -> new PriorityQueue<A>(as.toCollection());
+    return as -> new PriorityQueue<>(as.toCollection());
   }
 
   /**
@@ -677,7 +677,7 @@ public static <A> F<Option<A>, PriorityQueue<A>> Option_PriorityQueue() {
    */
   public static <A> F<Option<A>, Stack<A>> Option_Stack() {
     return as -> {
-      final Stack<A> s = new Stack<A>();
+      final Stack<A> s = new Stack<>();
       s.addAll(as.toCollection());
       return s;
     };
@@ -689,7 +689,7 @@ public static <A> F<Option<A>, Stack<A>> Option_Stack() {
    * @return A function that converts options to tree sets.
    */
   public static <A> F<Option<A>, TreeSet<A>> Option_TreeSet() {
-    return as -> new TreeSet<A>(as.toCollection());
+    return as -> new TreeSet<>(as.toCollection());
   }
 
   /**
@@ -698,7 +698,7 @@ public static <A> F<Option<A>, TreeSet<A>> Option_TreeSet() {
    * @return A function that converts options to vectors.
    */
   public static <A> F<Option<A>, Vector<A>> Option_Vector() {
-    return as -> new Vector<A>(as.toCollection());
+    return as -> new Vector<>(as.toCollection());
   }
 
   /**
@@ -708,7 +708,7 @@ public static <A> F<Option<A>, Vector<A>> Option_Vector() {
    * @return A function that converts options to array blocking queues.
    */
   public static <A> F<Option<A>, ArrayBlockingQueue<A>> Option_ArrayBlockingQueue(final boolean fair) {
-    return as -> new ArrayBlockingQueue<A>(as.length(), fair, as.toCollection());
+    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
   }
 
   /**
@@ -717,7 +717,7 @@ public static <A> F<Option<A>, ArrayBlockingQueue<A>> Option_ArrayBlockingQueue(
    * @return A function that converts options to concurrent linked queues.
    */
   public static <A> F<Option<A>, ConcurrentLinkedQueue<A>> Option_ConcurrentLinkedQueue() {
-    return as -> new ConcurrentLinkedQueue<A>(as.toCollection());
+    return as -> new ConcurrentLinkedQueue<>(as.toCollection());
   }
 
   /**
@@ -726,7 +726,7 @@ public static <A> F<Option<A>, ConcurrentLinkedQueue<A>> Option_ConcurrentLinked
    * @return A function that converts options to copy on write array lists.
    */
   public static <A> F<Option<A>, CopyOnWriteArrayList<A>> Option_CopyOnWriteArrayList() {
-    return as -> new CopyOnWriteArrayList<A>(as.toCollection());
+    return as -> new CopyOnWriteArrayList<>(as.toCollection());
   }
 
   /**
@@ -735,7 +735,7 @@ public static <A> F<Option<A>, CopyOnWriteArrayList<A>> Option_CopyOnWriteArrayL
    * @return A function that converts options to copy on write array sets.
    */
   public static <A> F<Option<A>, CopyOnWriteArraySet<A>> Option_CopyOnWriteArraySet() {
-    return as -> new CopyOnWriteArraySet<A>(as.toCollection());
+    return as -> new CopyOnWriteArraySet<>(as.toCollection());
   }
 
   /**
@@ -744,7 +744,7 @@ public static <A> F<Option<A>, CopyOnWriteArraySet<A>> Option_CopyOnWriteArraySe
    * @return A function that converts options to delay queues.
    */
   public static <A extends Delayed> F<Option<A>, DelayQueue<A>> Option_DelayQueue() {
-    return as -> new DelayQueue<A>(as.toCollection());
+    return as -> new DelayQueue<>(as.toCollection());
   }
 
   /**
@@ -753,7 +753,7 @@ public static <A extends Delayed> F<Option<A>, DelayQueue<A>> Option_DelayQueue(
    * @return A function that converts options to linked blocking queues.
    */
   public static <A> F<Option<A>, LinkedBlockingQueue<A>> Option_LinkedBlockingQueue() {
-    return as -> new LinkedBlockingQueue<A>(as.toCollection());
+    return as -> new LinkedBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -762,7 +762,7 @@ public static <A> F<Option<A>, LinkedBlockingQueue<A>> Option_LinkedBlockingQueu
    * @return A function that converts options to priority blocking queues.
    */
   public static <A> F<Option<A>, PriorityBlockingQueue<A>> Option_PriorityBlockingQueue() {
-    return as -> new PriorityBlockingQueue<A>(as.toCollection());
+    return as -> new PriorityBlockingQueue<>(as.toCollection());
   }
 
   /**
@@ -773,7 +773,7 @@ public static <A> F<Option<A>, PriorityBlockingQueue<A>> Option_PriorityBlocking
    */
   public static <A> F<Option<A>, SynchronousQueue<A>> Option_SynchronousQueue(final boolean fair) {
     return as -> {
-      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(as.toCollection());
       return q;
     };
@@ -789,7 +789,7 @@ public static <A> F<Option<A>, SynchronousQueue<A>> Option_SynchronousQueue(fina
    * @return A function that converts eithers to array lists.
    */
   public static <A, B> F<Either<A, B>, ArrayList<A>> Either_ArrayListA() {
-    return Function.compose(Java.<A>Option_ArrayList(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_ArrayList(), Conversions.Either_OptionA());
   }
 
   /**
@@ -798,7 +798,7 @@ public static <A, B> F<Either<A, B>, ArrayList<A>> Either_ArrayListA() {
    * @return A function that converts eithers to array lists.
    */
   public static <A, B> F<Either<A, B>, ArrayList<B>> Either_ArrayListB() {
-    return Function.compose(Java.<B>Option_ArrayList(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_ArrayList(), Conversions.Either_OptionB());
   }
 
   /**
@@ -807,7 +807,7 @@ public static <A, B> F<Either<A, B>, ArrayList<B>> Either_ArrayListB() {
    * @return A function that converts eithers to bit sets.
    */
   public static <B> F<Either<Boolean, B>, BitSet> Either_BitSetA() {
-    return Function.compose(Option_BitSet, Conversions.<Boolean, B>Either_OptionA());
+    return Function.compose(Option_BitSet, Conversions.Either_OptionA());
   }
 
   /**
@@ -816,7 +816,7 @@ public static <B> F<Either<Boolean, B>, BitSet> Either_BitSetA() {
    * @return A function that converts eithers to bit sets.
    */
   public static <A> F<Either<A, Boolean>, BitSet> Either_BitSetB() {
-    return Function.compose(Option_BitSet, Conversions.<A, Boolean>Either_OptionB());
+    return Function.compose(Option_BitSet, Conversions.Either_OptionB());
   }
 
   /**
@@ -843,7 +843,7 @@ public static <A, B extends Enum<B>> F<Either<A, B>, EnumSet<B>> Either_EnumSetB
    * @return A function that converts eithers to hash sets.
    */
   public static <A, B> F<Either<A, B>, HashSet<A>> Either_HashSetA() {
-    return Function.compose(Java.<A>Option_HashSet(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_HashSet(), Conversions.Either_OptionA());
   }
 
   /**
@@ -852,7 +852,7 @@ public static <A, B> F<Either<A, B>, HashSet<A>> Either_HashSetA() {
    * @return A function that converts eithers to hash sets.
    */
   public static <A, B> F<Either<A, B>, HashSet<B>> Either_HashSetB() {
-    return Function.compose(Java.<B>Option_HashSet(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_HashSet(), Conversions.Either_OptionB());
   }
 
   /**
@@ -861,7 +861,7 @@ public static <A, B> F<Either<A, B>, HashSet<B>> Either_HashSetB() {
    * @return A function that converts eithers to linked hash sets.
    */
   public static <A, B> F<Either<A, B>, LinkedHashSet<A>> Either_LinkedHashSetA() {
-    return Function.compose(Java.<A>Option_LinkedHashSet(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_LinkedHashSet(), Conversions.Either_OptionA());
   }
 
   /**
@@ -870,7 +870,7 @@ public static <A, B> F<Either<A, B>, LinkedHashSet<A>> Either_LinkedHashSetA() {
    * @return A function that converts eithers to linked hash sets.
    */
   public static <A, B> F<Either<A, B>, LinkedHashSet<B>> Either_LinkedHashSetB() {
-    return Function.compose(Java.<B>Option_LinkedHashSet(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_LinkedHashSet(), Conversions.Either_OptionB());
   }
 
   /**
@@ -879,7 +879,7 @@ public static <A, B> F<Either<A, B>, LinkedHashSet<B>> Either_LinkedHashSetB() {
    * @return A function that converts eithers to linked lists.
    */
   public static <A, B> F<Either<A, B>, LinkedList<A>> Either_LinkedListA() {
-    return Function.compose(Java.<A>Option_LinkedList(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_LinkedList(), Conversions.Either_OptionA());
   }
 
   /**
@@ -888,7 +888,7 @@ public static <A, B> F<Either<A, B>, LinkedList<A>> Either_LinkedListA() {
    * @return A function that eithers options to priority queues.
    */
   public static <A, B> F<Either<A, B>, PriorityQueue<A>> Option_PriorityQueueA() {
-    return Function.compose(Java.<A>Option_PriorityQueue(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_PriorityQueue(), Conversions.Either_OptionA());
   }
 
   /**
@@ -897,7 +897,7 @@ public static <A, B> F<Either<A, B>, PriorityQueue<A>> Option_PriorityQueueA() {
    * @return A function that eithers options to priority queues.
    */
   public static <A, B> F<Either<A, B>, PriorityQueue<B>> Option_PriorityQueueB() {
-    return Function.compose(Java.<B>Option_PriorityQueue(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_PriorityQueue(), Conversions.Either_OptionB());
   }
 
   /**
@@ -906,7 +906,7 @@ public static <A, B> F<Either<A, B>, PriorityQueue<B>> Option_PriorityQueueB() {
    * @return A function that converts eithers to linked lists.
    */
   public static <A, B> F<Either<A, B>, LinkedList<B>> Either_LinkedListB() {
-    return Function.compose(Java.<B>Option_LinkedList(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_LinkedList(), Conversions.Either_OptionB());
   }
 
   /**
@@ -915,7 +915,7 @@ public static <A, B> F<Either<A, B>, LinkedList<B>> Either_LinkedListB() {
    * @return A function that converts eithers to stacks.
    */
   public static <A, B> F<Either<A, B>, Stack<A>> Either_StackA() {
-    return Function.compose(Java.<A>Option_Stack(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_Stack(), Conversions.Either_OptionA());
   }
 
   /**
@@ -924,7 +924,7 @@ public static <A, B> F<Either<A, B>, Stack<A>> Either_StackA() {
    * @return A function that converts eithers to stacks.
    */
   public static <A, B> F<Either<A, B>, Stack<B>> Either_StackB() {
-    return Function.compose(Java.<B>Option_Stack(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_Stack(), Conversions.Either_OptionB());
   }
 
   /**
@@ -933,7 +933,7 @@ public static <A, B> F<Either<A, B>, Stack<B>> Either_StackB() {
    * @return A function that converts eithers to tree sets.
    */
   public static <A, B> F<Either<A, B>, TreeSet<A>> Either_TreeSetA() {
-    return Function.compose(Java.<A>Option_TreeSet(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_TreeSet(), Conversions.Either_OptionA());
   }
 
   /**
@@ -942,7 +942,7 @@ public static <A, B> F<Either<A, B>, TreeSet<A>> Either_TreeSetA() {
    * @return A function that converts eithers to tree sets.
    */
   public static <A, B> F<Either<A, B>, TreeSet<B>> Either_TreeSetB() {
-    return Function.compose(Java.<B>Option_TreeSet(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_TreeSet(), Conversions.Either_OptionB());
   }
 
   /**
@@ -951,7 +951,7 @@ public static <A, B> F<Either<A, B>, TreeSet<B>> Either_TreeSetB() {
    * @return A function that converts eithers to vectors.
    */
   public static <A, B> F<Either<A, B>, Vector<A>> Either_VectorA() {
-    return Function.compose(Java.<A>Option_Vector(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_Vector(), Conversions.Either_OptionA());
   }
 
   /**
@@ -960,7 +960,7 @@ public static <A, B> F<Either<A, B>, Vector<A>> Either_VectorA() {
    * @return A function that converts eithers to vectors.
    */
   public static <A, B> F<Either<A, B>, Vector<B>> Either_VectorB() {
-    return Function.compose(Java.<B>Option_Vector(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_Vector(), Conversions.Either_OptionB());
   }
 
   /**
@@ -970,7 +970,7 @@ public static <A, B> F<Either<A, B>, Vector<B>> Either_VectorB() {
    * @return A function that converts eithers to array blocking queues.
    */
   public static <A, B> F<Either<A, B>, ArrayBlockingQueue<A>> Either_ArrayBlockingQueueA(final boolean fair) {
-    return Function.compose(Java.<A>Option_ArrayBlockingQueue(fair), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_ArrayBlockingQueue(fair), Conversions.Either_OptionA());
   }
 
   /**
@@ -980,7 +980,7 @@ public static <A, B> F<Either<A, B>, ArrayBlockingQueue<A>> Either_ArrayBlocking
    * @return A function that converts eithers to array blocking queues.
    */
   public static <A, B> F<Either<A, B>, ArrayBlockingQueue<B>> Either_ArrayBlockingQueueB(final boolean fair) {
-    return Function.compose(Java.<B>Option_ArrayBlockingQueue(fair), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_ArrayBlockingQueue(fair), Conversions.Either_OptionB());
   }
 
   /**
@@ -989,7 +989,7 @@ public static <A, B> F<Either<A, B>, ArrayBlockingQueue<B>> Either_ArrayBlocking
    * @return A function that converts eithers to concurrent linked queues.
    */
   public static <A, B> F<Either<A, B>, ConcurrentLinkedQueue<A>> Either_ConcurrentLinkedQueueA() {
-    return Function.compose(Java.<A>Option_ConcurrentLinkedQueue(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_ConcurrentLinkedQueue(), Conversions.Either_OptionA());
   }
 
   /**
@@ -998,7 +998,7 @@ public static <A, B> F<Either<A, B>, ConcurrentLinkedQueue<A>> Either_Concurrent
    * @return A function that converts eithers to concurrent linked queues.
    */
   public static <A, B> F<Either<A, B>, ConcurrentLinkedQueue<B>> Either_ConcurrentLinkedQueueB() {
-    return Function.compose(Java.<B>Option_ConcurrentLinkedQueue(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_ConcurrentLinkedQueue(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1007,7 +1007,7 @@ public static <A, B> F<Either<A, B>, ConcurrentLinkedQueue<B>> Either_Concurrent
    * @return A function that converts eithers to copy on write array lists.
    */
   public static <A, B> F<Either<A, B>, CopyOnWriteArrayList<A>> Either_CopyOnWriteArrayListA() {
-    return Function.compose(Java.<A>Option_CopyOnWriteArrayList(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_CopyOnWriteArrayList(), Conversions.Either_OptionA());
   }
 
   /**
@@ -1016,7 +1016,7 @@ public static <A, B> F<Either<A, B>, CopyOnWriteArrayList<A>> Either_CopyOnWrite
    * @return A function that converts eithers to copy on write array lists.
    */
   public static <A, B> F<Either<A, B>, CopyOnWriteArrayList<B>> Either_CopyOnWriteArrayListB() {
-    return Function.compose(Java.<B>Option_CopyOnWriteArrayList(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_CopyOnWriteArrayList(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1025,7 +1025,7 @@ public static <A, B> F<Either<A, B>, CopyOnWriteArrayList<B>> Either_CopyOnWrite
    * @return A function that converts eithers to copy on write array sets.
    */
   public static <A, B> F<Either<A, B>, CopyOnWriteArraySet<A>> Either_CopyOnWriteArraySetA() {
-    return Function.compose(Java.<A>Option_CopyOnWriteArraySet(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_CopyOnWriteArraySet(), Conversions.Either_OptionA());
   }
 
   /**
@@ -1034,7 +1034,7 @@ public static <A, B> F<Either<A, B>, CopyOnWriteArraySet<A>> Either_CopyOnWriteA
    * @return A function that converts eithers to copy on write array sets.
    */
   public static <A, B> F<Either<A, B>, CopyOnWriteArraySet<B>> Either_CopyOnWriteArraySetB() {
-    return Function.compose(Java.<B>Option_CopyOnWriteArraySet(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_CopyOnWriteArraySet(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1043,7 +1043,7 @@ public static <A, B> F<Either<A, B>, CopyOnWriteArraySet<B>> Either_CopyOnWriteA
    * @return A function that converts eithers to delay queues.
    */
   public static <A extends Delayed, B> F<Either<A, B>, DelayQueue<A>> Either_DelayQueueA() {
-    return Function.compose(Java.<A>Option_DelayQueue(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_DelayQueue(), Conversions.Either_OptionA());
   }
 
   /**
@@ -1052,7 +1052,7 @@ public static <A extends Delayed, B> F<Either<A, B>, DelayQueue<A>> Either_Delay
    * @return A function that converts eithers to delay queues.
    */
   public static <A, B extends Delayed> F<Either<A, B>, DelayQueue<B>> Either_DelayQueueB() {
-    return Function.compose(Java.<B>Option_DelayQueue(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_DelayQueue(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1061,7 +1061,7 @@ public static <A, B extends Delayed> F<Either<A, B>, DelayQueue<B>> Either_Delay
    * @return A function that converts eithers to linked blocking queues.
    */
   public static <A, B> F<Either<A, B>, LinkedBlockingQueue<A>> Either_LinkedBlockingQueueA() {
-    return Function.compose(Java.<A>Option_LinkedBlockingQueue(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_LinkedBlockingQueue(), Conversions.Either_OptionA());
   }
 
   /**
@@ -1070,7 +1070,7 @@ public static <A, B> F<Either<A, B>, LinkedBlockingQueue<A>> Either_LinkedBlocki
    * @return A function that converts eithers to linked blocking queues.
    */
   public static <A, B> F<Either<A, B>, LinkedBlockingQueue<B>> Either_LinkedBlockingQueueB() {
-    return Function.compose(Java.<B>Option_LinkedBlockingQueue(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_LinkedBlockingQueue(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1079,7 +1079,7 @@ public static <A, B> F<Either<A, B>, LinkedBlockingQueue<B>> Either_LinkedBlocki
    * @return A function that converts eithers to priority blocking queues.
    */
   public static <A, B> F<Either<A, B>, PriorityBlockingQueue<A>> Either_PriorityBlockingQueueA() {
-    return Function.compose(Java.<A>Option_PriorityBlockingQueue(), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_PriorityBlockingQueue(), Conversions.Either_OptionA());
   }
 
   /**
@@ -1088,7 +1088,7 @@ public static <A, B> F<Either<A, B>, PriorityBlockingQueue<A>> Either_PriorityBl
    * @return A function that converts eithers to priority blocking queues.
    */
   public static <A, B> F<Either<A, B>, PriorityBlockingQueue<B>> Either_PriorityBlockingQueueB() {
-    return Function.compose(Java.<B>Option_PriorityBlockingQueue(), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_PriorityBlockingQueue(), Conversions.Either_OptionB());
   }
 
   /**
@@ -1098,7 +1098,7 @@ public static <A, B> F<Either<A, B>, PriorityBlockingQueue<B>> Either_PriorityBl
    * @return A function that converts eithers to synchronous queues.
    */
   public static <A, B> F<Either<A, B>, SynchronousQueue<A>> Either_SynchronousQueueA(final boolean fair) {
-    return Function.compose(Java.<A>Option_SynchronousQueue(fair), Conversions.<A, B>Either_OptionA());
+    return Function.compose(Java.Option_SynchronousQueue(fair), Conversions.Either_OptionA());
   }
 
   /**
@@ -1108,7 +1108,7 @@ public static <A, B> F<Either<A, B>, SynchronousQueue<A>> Either_SynchronousQueu
    * @return A function that converts eithers to synchronous queues.
    */
   public static <A, B> F<Either<A, B>, SynchronousQueue<B>> Either_SynchronousQueueB(final boolean fair) {
-    return Function.compose(Java.<B>Option_SynchronousQueue(fair), Conversions.<A, B>Either_OptionB());
+    return Function.compose(Java.Option_SynchronousQueue(fair), Conversions.Either_OptionB());
   }
 
   // END Either ->
@@ -1119,49 +1119,49 @@ public static <A, B> F<Either<A, B>, SynchronousQueue<B>> Either_SynchronousQueu
    * A function that converts strings to array lists.
    */
   public static final F<String, ArrayList<Character>> String_ArrayList =
-      Function.compose(Java.<Character>List_ArrayList(), Conversions.String_List);
+      Function.compose(Java.List_ArrayList(), Conversions.String_List);
 
   /**
    * A function that converts strings to hash sets.
    */
   public static final F<String, HashSet<Character>> String_HashSet =
-      Function.compose(Java.<Character>List_HashSet(), Conversions.String_List);
+      Function.compose(Java.List_HashSet(), Conversions.String_List);
 
   /**
    * A function that converts strings to linked hash sets.
    */
   public static final F<String, LinkedHashSet<Character>> String_LinkedHashSet =
-      Function.compose(Java.<Character>List_LinkedHashSet(), Conversions.String_List);
+      Function.compose(Java.List_LinkedHashSet(), Conversions.String_List);
 
   /**
    * A function that converts strings to linked lists.
    */
   public static final F<String, LinkedList<Character>> String_LinkedList =
-      Function.compose(Java.<Character>List_LinkedList(), Conversions.String_List);
+      Function.compose(Java.List_LinkedList(), Conversions.String_List);
 
   /**
    * A function that converts strings to priority queues.
    */
   public static final F<String, PriorityQueue<Character>> String_PriorityQueue =
-      Function.compose(Java.<Character>List_PriorityQueue(), Conversions.String_List);
+      Function.compose(Java.List_PriorityQueue(), Conversions.String_List);
 
   /**
    * A function that converts strings to stacks.
    */
   public static final F<String, Stack<Character>> String_Stack =
-      Function.compose(Java.<Character>List_Stack(), Conversions.String_List);
+      Function.compose(Java.List_Stack(), Conversions.String_List);
 
   /**
    * A function that converts strings to tree sets.
    */
   public static final F<String, TreeSet<Character>> String_TreeSet =
-      Function.compose(Java.<Character>List_TreeSet(), Conversions.String_List);
+      Function.compose(Java.List_TreeSet(), Conversions.String_List);
 
   /**
    * A function that converts strings to vectors.
    */
   public static final F<String, Vector<Character>> String_Vector =
-      Function.compose(Java.<Character>List_Vector(), Conversions.String_List);
+      Function.compose(Java.List_Vector(), Conversions.String_List);
 
   /**
    * A function that converts strings to array blocking queues.
@@ -1170,38 +1170,38 @@ public static <A, B> F<Either<A, B>, SynchronousQueue<B>> Either_SynchronousQueu
    * @return A function that converts strings to array blocking queues.
    */
   public static F<String, ArrayBlockingQueue<Character>> String_ArrayBlockingQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_ArrayBlockingQueue(fair), Conversions.String_List);
+    return Function.compose(Java.List_ArrayBlockingQueue(fair), Conversions.String_List);
   }
 
   /**
    * A function that converts strings to concurrent linked queues.
    */
   public static final F<String, ConcurrentLinkedQueue<Character>> String_ConcurrentLinkedQueue =
-      Function.compose(Java.<Character>List_ConcurrentLinkedQueue(), Conversions.String_List);
+      Function.compose(Java.List_ConcurrentLinkedQueue(), Conversions.String_List);
 
   /**
    * A function that converts strings to copy on write array lists.
    */
   public static final F<String, CopyOnWriteArrayList<Character>> String_CopyOnWriteArrayList =
-      Function.compose(Java.<Character>List_CopyOnWriteArrayList(), Conversions.String_List);
+      Function.compose(Java.List_CopyOnWriteArrayList(), Conversions.String_List);
 
   /**
    * A function that converts strings to copy on write array sets.
    */
   public static final F<String, CopyOnWriteArraySet<Character>> String_CopyOnWriteArraySet =
-      Function.compose(Java.<Character>List_CopyOnWriteArraySet(), Conversions.String_List);
+      Function.compose(Java.List_CopyOnWriteArraySet(), Conversions.String_List);
 
   /**
    * A function that converts strings to linked blocking queues.
    */
   public static final F<String, LinkedBlockingQueue<Character>> String_LinkedBlockingQueue =
-      Function.compose(Java.<Character>List_LinkedBlockingQueue(), Conversions.String_List);
+      Function.compose(Java.List_LinkedBlockingQueue(), Conversions.String_List);
 
   /**
    * A function that converts strings to priority blocking queues.
    */
   public static final F<String, PriorityBlockingQueue<Character>> String_PriorityBlockingQueue =
-      Function.compose(Java.<Character>List_PriorityBlockingQueue(), Conversions.String_List);
+      Function.compose(Java.List_PriorityBlockingQueue(), Conversions.String_List);
 
   /**
    * A function that converts strings to synchronous queues.
@@ -1210,7 +1210,7 @@ public static F<String, ArrayBlockingQueue<Character>> String_ArrayBlockingQueue
    * @return A function that converts strings to synchronous queues.
    */
   public static F<String, SynchronousQueue<Character>> String_SynchronousQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_SynchronousQueue(fair), Conversions.String_List);
+    return Function.compose(Java.List_SynchronousQueue(fair), Conversions.String_List);
   }
 
   // END String ->
@@ -1221,49 +1221,49 @@ public static F<String, SynchronousQueue<Character>> String_SynchronousQueue(fin
    * A function that converts string buffers to array lists.
    */
   public static final F<StringBuffer, ArrayList<Character>> StringBuffer_ArrayList =
-      Function.compose(Java.<Character>List_ArrayList(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_ArrayList(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to hash sets.
    */
   public static final F<StringBuffer, HashSet<Character>> StringBuffer_HashSet =
-      Function.compose(Java.<Character>List_HashSet(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_HashSet(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to linked hash sets.
    */
   public static final F<StringBuffer, LinkedHashSet<Character>> StringBuffer_LinkedHashSet =
-      Function.compose(Java.<Character>List_LinkedHashSet(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_LinkedHashSet(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to linked lists.
    */
   public static final F<StringBuffer, LinkedList<Character>> StringBuffer_LinkedList =
-      Function.compose(Java.<Character>List_LinkedList(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_LinkedList(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to priority queues.
    */
   public static final F<StringBuffer, PriorityQueue<Character>> StringBuffer_PriorityQueue =
-      Function.compose(Java.<Character>List_PriorityQueue(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_PriorityQueue(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to stacks.
    */
   public static final F<StringBuffer, Stack<Character>> StringBuffer_Stack =
-      Function.compose(Java.<Character>List_Stack(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_Stack(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to tree sets.
    */
   public static final F<StringBuffer, TreeSet<Character>> StringBuffer_TreeSet =
-      Function.compose(Java.<Character>List_TreeSet(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_TreeSet(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to vectors.
    */
   public static final F<StringBuffer, Vector<Character>> StringBuffer_Vector =
-      Function.compose(Java.<Character>List_Vector(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_Vector(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to array blocking queues.
@@ -1272,38 +1272,38 @@ public static F<String, SynchronousQueue<Character>> String_SynchronousQueue(fin
    * @return A function that converts string buffers to array blocking queues.
    */
   public static F<StringBuffer, ArrayBlockingQueue<Character>> StringBuffer_ArrayBlockingQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_ArrayBlockingQueue(fair), Conversions.StringBuffer_List);
+    return Function.compose(Java.List_ArrayBlockingQueue(fair), Conversions.StringBuffer_List);
   }
 
   /**
    * A function that converts string buffers to concurrent linked queues.
    */
   public static final F<StringBuffer, ConcurrentLinkedQueue<Character>> StringBuffer_ConcurrentLinkedQueue =
-      Function.compose(Java.<Character>List_ConcurrentLinkedQueue(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_ConcurrentLinkedQueue(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to copy on write array lists.
    */
   public static final F<StringBuffer, CopyOnWriteArrayList<Character>> StringBuffer_CopyOnWriteArrayList =
-      Function.compose(Java.<Character>List_CopyOnWriteArrayList(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_CopyOnWriteArrayList(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to copy on write array sets.
    */
   public static final F<StringBuffer, CopyOnWriteArraySet<Character>> StringBuffer_CopyOnWriteArraySet =
-      Function.compose(Java.<Character>List_CopyOnWriteArraySet(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_CopyOnWriteArraySet(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to linked blocking queues.
    */
   public static final F<StringBuffer, LinkedBlockingQueue<Character>> StringBuffer_LinkedBlockingQueue =
-      Function.compose(Java.<Character>List_LinkedBlockingQueue(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_LinkedBlockingQueue(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to priority blocking queues.
    */
   public static final F<StringBuffer, PriorityBlockingQueue<Character>> StringBuffer_PriorityBlockingQueue =
-      Function.compose(Java.<Character>List_PriorityBlockingQueue(), Conversions.StringBuffer_List);
+      Function.compose(Java.List_PriorityBlockingQueue(), Conversions.StringBuffer_List);
 
   /**
    * A function that converts string buffers to synchronous queues.
@@ -1312,7 +1312,7 @@ public static F<StringBuffer, ArrayBlockingQueue<Character>> StringBuffer_ArrayB
    * @return A function that converts string buffers to synchronous queues.
    */
   public static F<StringBuffer, SynchronousQueue<Character>> StringBuffer_SynchronousQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_SynchronousQueue(fair), Conversions.StringBuffer_List);
+    return Function.compose(Java.List_SynchronousQueue(fair), Conversions.StringBuffer_List);
   }
 
   // END StringBuffer ->
@@ -1323,49 +1323,49 @@ public static F<StringBuffer, SynchronousQueue<Character>> StringBuffer_Synchron
    * A function that converts string builders to array lists.
    */
   public static final F<StringBuilder, ArrayList<Character>> StringBuilder_ArrayList =
-      Function.compose(Java.<Character>List_ArrayList(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_ArrayList(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to hash sets.
    */
   public static final F<StringBuilder, HashSet<Character>> StringBuilder_HashSet =
-      Function.compose(Java.<Character>List_HashSet(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_HashSet(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to linked hash sets.
    */
   public static final F<StringBuilder, LinkedHashSet<Character>> StringBuilder_LinkedHashSet =
-      Function.compose(Java.<Character>List_LinkedHashSet(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_LinkedHashSet(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to linked lists.
    */
   public static final F<StringBuilder, LinkedList<Character>> StringBuilder_LinkedList =
-      Function.compose(Java.<Character>List_LinkedList(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_LinkedList(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to priority queues.
    */
   public static final F<StringBuilder, PriorityQueue<Character>> StringBuilder_PriorityQueue =
-      Function.compose(Java.<Character>List_PriorityQueue(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_PriorityQueue(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to stacks.
    */
   public static final F<StringBuilder, Stack<Character>> StringBuilder_Stack =
-      Function.compose(Java.<Character>List_Stack(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_Stack(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to tree sets.
    */
   public static final F<StringBuilder, TreeSet<Character>> StringBuilder_TreeSet =
-      Function.compose(Java.<Character>List_TreeSet(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_TreeSet(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to vectors.
    */
   public static final F<StringBuilder, Vector<Character>> StringBuilder_Vector =
-      Function.compose(Java.<Character>List_Vector(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_Vector(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to array blocking queues.
@@ -1374,38 +1374,38 @@ public static F<StringBuffer, SynchronousQueue<Character>> StringBuffer_Synchron
    * @return A function that converts string builders to array blocking queues.
    */
   public static F<StringBuilder, ArrayBlockingQueue<Character>> StringBuilder_ArrayBlockingQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_ArrayBlockingQueue(fair), Conversions.StringBuilder_List);
+    return Function.compose(Java.List_ArrayBlockingQueue(fair), Conversions.StringBuilder_List);
   }
 
   /**
    * A function that converts string builders to concurrent linked queues.
    */
   public static final F<StringBuilder, ConcurrentLinkedQueue<Character>> StringBuilder_ConcurrentLinkedQueue =
-      Function.compose(Java.<Character>List_ConcurrentLinkedQueue(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_ConcurrentLinkedQueue(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to copy on write array lists.
    */
   public static final F<StringBuilder, CopyOnWriteArrayList<Character>> StringBuilder_CopyOnWriteArrayList =
-      Function.compose(Java.<Character>List_CopyOnWriteArrayList(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_CopyOnWriteArrayList(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to copy on write array sets.
    */
   public static final F<StringBuilder, CopyOnWriteArraySet<Character>> StringBuilder_CopyOnWriteArraySet =
-      Function.compose(Java.<Character>List_CopyOnWriteArraySet(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_CopyOnWriteArraySet(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to linked blocking queues.
    */
   public static final F<StringBuilder, LinkedBlockingQueue<Character>> StringBuilder_LinkedBlockingQueue =
-      Function.compose(Java.<Character>List_LinkedBlockingQueue(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_LinkedBlockingQueue(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to priority blocking queues.
    */
   public static final F<StringBuilder, PriorityBlockingQueue<Character>> StringBuilder_PriorityBlockingQueue =
-      Function.compose(Java.<Character>List_PriorityBlockingQueue(), Conversions.StringBuilder_List);
+      Function.compose(Java.List_PriorityBlockingQueue(), Conversions.StringBuilder_List);
 
   /**
    * A function that converts string builders to synchronous queues.
@@ -1414,7 +1414,7 @@ public static F<StringBuilder, ArrayBlockingQueue<Character>> StringBuilder_Arra
    * @return A function that converts string builders to synchronous queues.
    */
   public static F<StringBuilder, SynchronousQueue<Character>> StringBuilder_SynchronousQueue(final boolean fair) {
-    return Function.compose(Java.<Character>List_SynchronousQueue(fair), Conversions.StringBuilder_List);
+    return Function.compose(Java.List_SynchronousQueue(fair), Conversions.StringBuilder_List);
   }
 
   // END StringBuffer ->
@@ -1458,7 +1458,7 @@ public static <A> List<A> JavaList_List(java.util.List<A> list) {
    * A function that converts bit sets to lists.
    */
   public static final F<BitSet, List<Boolean>> BitSet_List = s -> List.unfold(i -> i == s.length() ?
-      Option.<P2<Boolean, Integer>>none() :
+      Option.none() :
       some(p(s.get(i), i + 1)), 0);
 
   // todo
@@ -1481,7 +1481,7 @@ public static <A> List<A> Collection_List(Collection<A> c) {
 	}
 
 	public static <A> F<Collection<A>, List<A>> Collection_List() {
-		return c -> List.<A>list(c.toArray(array(c.size())));
+		return c -> List.list(c.toArray(array(c.size())));
 	}
 
 	@SafeVarargs
diff --git a/core/src/main/java/fj/data/LazyString.java b/core/src/main/java/fj/data/LazyString.java
index 2583621f..3e393cf8 100644
--- a/core/src/main/java/fj/data/LazyString.java
+++ b/core/src/main/java/fj/data/LazyString.java
@@ -256,7 +256,7 @@ public boolean matches(final String regex) {
   public Stream<LazyString> split(final F<Character, Boolean> p) {
     final Stream<Character> findIt = s.dropWhile(p);
     final P2<Stream<Character>, Stream<Character>> ws = findIt.split(p);
-    return findIt.isEmpty() ? Stream.<LazyString>nil()
+    return findIt.isEmpty() ? Stream.nil()
                             : Stream.cons(fromStream(ws._1()), () -> fromStream(ws._2()).split(p));
   }
 
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 5a2e2504..399cc016 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -167,7 +167,7 @@ public final Option<A> toOption() {
    * @return The optional head of the list.
    */
   public Option<A> headOption() {
-    return isEmpty() ? Option.<A>none() : some(head());
+    return isEmpty() ? Option.none() : some(head());
   }
 
   /**
@@ -178,7 +178,7 @@ public Option<A> headOption() {
    * @return An either projection of this list.
    */
   public final <X> Either<X, A> toEither(final F0<X> x) {
-    return isEmpty() ? Either.<X, A>left(x.f()) : Either.<X, A>right(head());
+    return isEmpty() ? Either.left(x.f()) : Either.right(head());
   }
 
   /**
@@ -258,7 +258,7 @@ public final A[] array(final Class<A[]> c) {
    * @return A new list with the given element at the head.
    */
   public final List<A> cons(final A a) {
-    return new Cons<A>(a, this);
+    return new Cons<>(a, this);
   }
 
   /**
@@ -269,7 +269,7 @@ public final List<A> cons(final A a) {
    * @return A new list with the given element at the head.
    */
   public final List<A> conss(final A a) {
-    return new Cons<A>(a, this);
+    return new Cons<>(a, this);
   }
 
   /**
@@ -412,7 +412,7 @@ public final P2<List<A>, List<A>> span(final F<A, Boolean> p) {
       else
         return p(b.toList(), xs);
     }
-    return p(b.toList(), List.<A>nil());
+    return p(b.toList(), List.nil());
   }
 
   /**
@@ -614,7 +614,7 @@ public final <B> List<B> sequence(final List<B> bs) {
     public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
         return foldRight(
                 (a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),
-                some(List.<B>nil())
+                some(List.nil())
         );
     }
 
@@ -627,67 +627,67 @@ public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
     public <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {
         return foldRight(
                 (a, acc) -> f.f(a).right().bind(e -> acc.right().map(es -> es.cons(e))),
-                Either.<E, List<B>>right(List.<B>nil())
+                Either.right(List.nil())
         );
     }
 
     public <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
         return foldRight(
                 (a, acc) -> f.f(a).bind(s -> acc.map(ss -> ss.cons(s))),
-                Stream.<List<B>>nil()
+                Stream.nil()
         );
     }
 
     public <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
         return foldRight(
                 (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-                p(List.<B>nil())
+                p(List.nil())
         );
     }
 
     public <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
         return this.foldRight(
                 (a, acc) -> IOFunctions.bind(f.f(a), b -> IOFunctions.map(acc, bs -> bs.cons(b))),
-                IOFunctions.unit(List.<B>nil())
+                IOFunctions.unit(List.nil())
         );
     }
 
   public <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
     return this.foldRight(
         (a, acc) -> Function.bind(acc,
-            (bs) -> Function.<C, B, List<B>> compose(bs::cons, f.f(a))),
-        constant(List.<B> nil())
+            (bs) -> Function.compose(bs::cons, f.f(a))),
+        constant(List.nil())
         );
   }
 
   public <B> Trampoline<List<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        Trampoline.pure(List.<B> nil()));
+        Trampoline.pure(List.nil()));
   }
 
   public <B> Promise<List<B>> traversePromise(final F<A, Promise<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.fmap(bs -> bs.cons(b))),
-        Promise.promise(Strategy.idStrategy(), p(List.<B> nil())));
+        Promise.promise(Strategy.idStrategy(), p(List.nil())));
   }
 
   public <B> List<List<B>> traverseList(final F<A, List<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        single(List.<B> nil()));
+        single(List.nil()));
   }
 
   public <E, B> Validation<E, List<B>> traverseValidation(final F<A, Validation<E, B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        Validation.success(List.<B> nil()));
+        Validation.success(List.nil()));
   }
 
   public <B> V2<List<B>> traverseV2(final F<A, V2<B>> f) {
     return foldRight(
         (a, acc) -> acc.apply(f.f(a).<F<List<B>, List<B>>> map(e -> es -> es.cons(e))),
-        v(List.<B> nil(), List.<B> nil()));
+        v(List.nil(), List.nil()));
   }
 
     /**
@@ -800,7 +800,7 @@ public final A foldLeft1(final F<A, F<A, A>> f) {
    * @return A new list that is the reverse of this one.
    */
   public final List<A> reverse() {
-    return foldLeft(as -> a -> cons(a, as), List.<A>nil());
+    return foldLeft(as -> a -> cons(a, as), List.nil());
   }
 
   /**
@@ -865,7 +865,7 @@ public final List<A> drop(final int i) {
    */
   public final P2<List<A>, List<A>> splitAt(final int i) {
     int c = 0;
-    List<A> first = List.<A>nil();
+    List<A> first = List.nil();
     List<A> second = nil();
     for (List<A> xs = this; xs.isNotEmpty(); xs = xs.tail()) {
       final A h = xs.head();
@@ -891,7 +891,7 @@ public final List<List<A>> partition(final int n) {
       throw error("Can't create list partitions shorter than 1 element long.");
     if (isEmpty())
       throw error("Partition on empty list.");
-    return unfold(as -> as.isEmpty() ? Option.<P2<List<A>, List<A>>>none() : some(as.splitAt(n)), this);
+    return unfold(as -> as.isEmpty() ? Option.none() : some(as.splitAt(n)), this);
   }
 
   /**
@@ -916,7 +916,7 @@ public P2<List<A>, List<A>> partition(F<A, Boolean> f) {
    * @return The list of initial segments of this list, shortest first.
    */
   public final List<List<A>> inits() {
-    List<List<A>> s = single(List.<A>nil());
+    List<List<A>> s = single(List.nil());
     if (isNotEmpty())
       s = s.append(tail().inits().map(List.<A>cons().f(head())));
     return s;
@@ -928,7 +928,7 @@ public final List<List<A>> inits() {
    * @return The list of final segments of this list, longest first.
    */
   public final List<List<A>> tails() {
-    return isEmpty() ? single(List.<A>nil()) : cons(this, tail().tails());
+    return isEmpty() ? single(List.nil()) : cons(this, tail().tails());
   }
 
   /**
@@ -1133,7 +1133,7 @@ public final List<A> intercalate(final List<List<A>> as) {
    * @return A list without duplicates according to object equality.
    */
   public final List<A> nub() {
-    return nub(Equal.<A>anyEqual());
+    return nub(Equal.anyEqual());
   }
 
   /**
@@ -1154,7 +1154,7 @@ public final List<A> nub(final Equal<A> eq) {
    */
   @SuppressWarnings("unchecked")
   public final List<A> nub(final Ord<A> o) {
-    return sort(o).group(o.equal()).map(List.<A>head_());
+    return sort(o).group(o.equal()).map(List.head_());
   }
 
 
@@ -1227,7 +1227,7 @@ public final <B> Option<List<B>> mapMOption(final F<A, Option<B>> f) {
    * @return A list of values in the Trampoline monad.
    */
   public final <B> Trampoline<List<B>> mapMTrampoline(final F<A, Trampoline<B>> f) {
-    return foldRight((a, bs) -> f.f(a).bind(b -> bs.map(bbs -> bbs.cons(b))), Trampoline.<List<B>>pure(List.<B>nil()));
+    return foldRight((a, bs) -> f.f(a).bind(b -> bs.map(bbs -> bbs.cons(b))), Trampoline.pure(List.nil()));
   }
 
   /**
@@ -1296,7 +1296,7 @@ public final List<A> insertBy(final F<A, F<A, Ordering>> f, final A x) {
    * @return The most common element in this list.
    */
   public final A mode(final Ord<A> o) {
-    return sort(o).group(o.equal()).maximum(intOrd.contramap(List.<A>length_())).head();
+    return sort(o).group(o.equal()).maximum(intOrd.contramap(List.length_())).head();
   }
 
   /**
@@ -1350,7 +1350,7 @@ public final <B, C> TreeMap<B, List<C>> groupBy(
       final F<A, B> keyFunction,
       final F<A, C> valueFunction,
       final Ord<B> keyOrd) {
-    return this.<B, C, List<C>>groupBy(keyFunction, valueFunction, List.<C>nil(), List::cons, keyOrd);
+    return this.groupBy(keyFunction, valueFunction, List.nil(), List::cons, keyOrd);
   }
 
   /**
@@ -1398,7 +1398,7 @@ public final <B, C, D> TreeMap<B, D> groupBy(
           return map.set(key, map.get(key)
               .map(existing -> groupingAcc.f(value, existing))
               .orSome(groupingAcc.f(value, groupingIdentity)));
-        }, TreeMap.<B, D>empty(keyOrd)
+        }, TreeMap.empty(keyOrd)
     );
   }
 
@@ -1470,7 +1470,7 @@ public final A minimum(final Ord<A> o) {
   }
 
   public final java.util.List<A> toJavaList() {
-    return new java.util.LinkedList<A>(toCollection());
+    return new java.util.LinkedList<>(toCollection());
   }
 
   /**
@@ -1511,7 +1511,7 @@ public int size() {
   }
 
   private static final class Nil<A> extends List<A> {
-    public static final Nil<Object> INSTANCE = new Nil<Object>();
+    public static final Nil<Object> INSTANCE = new Nil<>();
 
     public A head() {
       throw error("head on empty list");
@@ -1638,7 +1638,7 @@ public static <A> F<List<A>, List<A>> cons_(final A a) {
    * @return The list with the given element prepended.
    */
   public static <A> List<A> cons(final A head, final List<A> tail) {
-    return new Cons<A>(head, tail);
+    return new Cons<>(head, tail);
   }
 
   /**
@@ -1798,7 +1798,7 @@ public static F<List<Character>, String> asString() {
    * @return A list of one element containing the given value.
    */
   public static <A> List<A> single(final A a) {
-    return cons(a, List.<A>nil());
+    return cons(a, List.nil());
   }
 
   /**
@@ -1826,7 +1826,7 @@ public static <A> List<A> iterateWhile(final F<A, A> f, final F<A, Boolean> p, f
    * @return An associated value with the given key in the list of pairs.
    */
   public static <A, B> Option<B> lookup(final Equal<A> e, final List<P2<A, B>> x, final A a) {
-    return x.find(p -> e.eq(p._1(), a)).map(P2.<A, B>__2());
+    return x.find(p -> e.eq(p._1(), a)).map(P2.__2());
   }
 
   /**
@@ -1865,8 +1865,8 @@ public static <A, B> F<F<A, B>, F<List<A>, List<B>>> map_() {
    *         and returns a list of the results.
    */
   public static <A, B> F<B, List<A>> sequence_(final List<F<B, A>> fs) {
-    return fs.foldRight(Function.<A, List<A>, List<A>, B>lift(List.<A>cons()), Function
-        .<B, List<A>>constant(List.<A>nil()));
+    return fs.foldRight(Function.lift(List.cons()), Function
+        .constant(List.nil()));
   }
 
   /**
@@ -1936,7 +1936,7 @@ public Buffer<A> snoc(final A a) {
       if (exported)
         copy();
 
-      final Cons<A> t = new Cons<A>(a, List.<A>nil());
+      final Cons<A> t = new Cons<>(a, List.nil());
 
       if (tail == null)
         start = t;
@@ -2009,7 +2009,7 @@ public Collection<A> toCollection() {
      * @return An empty buffer.
      */
     public static <A> Buffer<A> empty() {
-      return new Buffer<A>();
+      return new Buffer<>();
     }
 
     /**
@@ -2019,7 +2019,7 @@ public static <A> Buffer<A> empty() {
      * @return A buffer from the given list.
      */
     public static <A> Buffer<A> fromList(final List<A> as) {
-      final Buffer<A> b = new Buffer<A>();
+      final Buffer<A> b = new Buffer<>();
 
       for (List<A> xs = as; xs.isNotEmpty(); xs = xs.tail())
         b.snoc(xs.head());
@@ -2067,7 +2067,7 @@ private void copy() {
      * @return true if this list is equal to the provided argument
      */
     @Override public boolean equals( final Object obj ) {
-        return Equal.equals0(List.class, this, obj, () -> Equal.listEqual(Equal.<A>anyEqual()));
+        return Equal.equals0(List.class, this, obj, () -> Equal.listEqual(Equal.anyEqual()));
     }
 
     /**
diff --git a/core/src/main/java/fj/data/Natural.java b/core/src/main/java/fj/data/Natural.java
index 1779d8c7..23080a49 100644
--- a/core/src/main/java/fj/data/Natural.java
+++ b/core/src/main/java/fj/data/Natural.java
@@ -32,7 +32,7 @@ private Natural(final BigInteger i) {
    */
   public static Option<Natural> natural(final BigInteger i) {
     return i.compareTo(BigInteger.ZERO) < 0
-           ? Option.<Natural>none()
+           ? Option.none()
            : Option.some(new Natural(i));
   }
 
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index c8dd4cca..013b287c 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -79,7 +79,7 @@ public NonEmptyList<A> snoc(final A a) {
    * @return A new list with the given list appended.
    */
   public NonEmptyList<A> append(final NonEmptyList<A> as) {
-    final List.Buffer<A> b = new List.Buffer<A>();
+    final List.Buffer<A> b = new List.Buffer<>();
     b.append(tail);
     b.snoc(as.head);
     b.append(as.tail);
@@ -104,7 +104,7 @@ public <B> NonEmptyList<B> map(final F<A, B> f) {
    * @return A new list after performing the map, then final join.
    */
   public <B> NonEmptyList<B> bind(final F<A, NonEmptyList<B>> f) {
-    final List.Buffer<B> b = new List.Buffer<B>();
+    final List.Buffer<B> b = new List.Buffer<>();
     final NonEmptyList<B> p = f.f(head);
     b.snoc(p.head);
     b.append(p.tail);
@@ -125,7 +125,7 @@ public <B> NonEmptyList<B> bind(final F<A, NonEmptyList<B>> f) {
   public NonEmptyList<NonEmptyList<A>> sublists() {
     return fromList(
         somes(toList().toStream().substreams()
-            .map(F1Functions.o(NonEmptyList::fromList, Conversions.<A>Stream_List())).toList())).some();
+            .map(F1Functions.o(NonEmptyList::fromList, Conversions.Stream_List())).toList())).some();
   }
 
   /**
@@ -277,7 +277,7 @@ public static <A> F<NonEmptyList<A>, List<A>> toList_() {
    * @return A non-empty list with the given head and tail.
    */
   public static <A> NonEmptyList<A> nel(final A head, final List<A> tail) {
-    return new NonEmptyList<A>(head, tail);
+    return new NonEmptyList<>(head, tail);
   }
 
   /**
@@ -308,7 +308,7 @@ public static <A> F<A, NonEmptyList<A>> nel() {
    */
   public static <A> Option<NonEmptyList<A>> fromList(final List<A> as) {
     return as.isEmpty() ?
-           Option.<NonEmptyList<A>>none() :
+           Option.none() :
            some(nel(as.head(), as.tail()));
   }
 
@@ -328,7 +328,7 @@ public static <A> Option<NonEmptyList<A>> fromList(final List<A> as) {
    * @return true if this list is equal to the provided argument
    */
   @Override public boolean equals( final Object obj ) {
-    return Equal.equals0(NonEmptyList.class, this, obj, () -> Equal.nonEmptyListEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(NonEmptyList.class, this, obj, () -> Equal.nonEmptyListEqual(Equal.anyEqual()));
   }
 
   @Override public int hashCode() {
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 5c8dca74..1ec77980 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -191,7 +191,7 @@ public final A valueE(final String message) {
    * @return A new optional value after the given function has been applied to its element.
    */
   public final <B> Option<B> map(final F<A, B> f) {
-    return isSome() ? some(f.f(some())) : Option.<B>none();
+    return isSome() ? some(f.f(some())) : Option.none();
   }
 
   /**
@@ -231,7 +231,7 @@ public final void foreachDoEffect(final Effect1<A> f) {
    * @return A new optional value whose value matches the given predicate if it has one.
    */
   public final Option<A> filter(final F<A, Boolean> f) {
-    return isSome() ? f.f(some()) ? this : Option.<A>none() : Option.<A>none();
+    return isSome() ? f.f(some()) ? this : Option.none() : Option.none();
   }
 
   /**
@@ -241,7 +241,7 @@ public final Option<A> filter(final F<A, Boolean> f) {
    * @return A new optional value after performing the map, then final join.
    */
   public final <B> Option<B> bind(final F<A, Option<B>> f) {
-    return isSome() ? f.f(some()) : Option.<B>none();
+    return isSome() ? f.f(some()) : Option.none();
   }
 
   /**
@@ -366,38 +366,38 @@ public final <B, C, D, E> Option<E> bind(final Option<B> ob, final Option<C> oc,
   }
 
   public final <B> Option<P2<A,B>> bindProduct(final Option<B> ob) {
-    return bind(ob, P.<A,B>p2()); 
+    return bind(ob, P.p2());
   }
 
   public final <B, C> Option<P3<A,B,C>> bindProduct(final Option<B> ob, final Option<C> oc) {
-    return bind(ob, oc, P.<A,B,C>p3());
+    return bind(ob, oc, P.p3());
   }
   
   public final <B, C, D> Option<P4<A,B,C,D>> bindProduct(final Option<B> ob, final Option<C> oc, final Option<D> od) {
-    return bind(ob, oc, od, P.<A, B, C, D>p4());
+    return bind(ob, oc, od, P.p4());
   }
   
   public final <B,C,D,E> Option<P5<A,B,C,D,E>> bindProduct(final Option<B> ob, final Option<C> oc, final Option<D> od,
                                                      final Option<E> oe) {
-    return bind(ob, oc, od, oe, P.<A, B, C, D, E>p5());
+    return bind(ob, oc, od, oe, P.p5());
   }
 
   public final <B,C,D,E,F$> Option<P6<A,B,C,D,E,F$>> bindProduct(final Option<B> ob, final Option<C> oc, final Option<D> od,
                                                            final Option<E> oe, final Option<F$> of) {
-    return bind(ob, oc, od, oe, of, P.<A, B, C, D, E, F$>p6());
+    return bind(ob, oc, od, oe, of, P.p6());
   }
 
   public final <B,C,D,E,F$,G> Option<P7<A,B,C,D,E,F$,G>> bindProduct(final Option<B> ob, final Option<C> oc,
                                                                final Option<D> od, final Option<E> oe,
                                                                final Option<F$> of, final Option<G> og) {
-    return bind(ob, oc, od, oe, of, og, P.<A, B, C, D, E, F$, G>p7());
+    return bind(ob, oc, od, oe, of, og, P.p7());
   }
 
   public final <B,C,D,E,F$,G,H> Option<P8<A,B,C,D,E,F$,G,H>> bindProduct(final Option<B> ob, final Option<C> oc,
                                                                    final Option<D> od, final Option<E> oe,
                                                                    final Option<F$> of, final Option<G> og,
                                                                    final Option<H> oh) {
-    return bind(ob, oc, od, oe, of, og, oh, P.<A,B,C,D,E,F$,G,H>p8());
+    return bind(ob, oc, od, oe, of, og, oh, P.p8());
   }
 
   /**
@@ -491,7 +491,7 @@ public final Option<A> orElse(final Option<A> o) {
    * @return An either projection of this optional value.
    */
   public final <X> Either<X, A> toEither(final F0<X> x) {
-    return isSome() ? Either.<X, A>right(some()) : Either.<X, A>left(x.f());
+    return isSome() ? Either.right(some()) : Either.left(x.f());
   }
 
   /**
@@ -502,7 +502,7 @@ public final <X> Either<X, A> toEither(final F0<X> x) {
    * @return An either projection of this optional value.
    */
   public final <X> Either<X, A> toEither(final X x) {
-    return isSome() ? Either.<X, A>right(some()) : Either.<X, A>left(x);
+    return isSome() ? Either.right(some()) : Either.left(x);
   }
 
     public final <X> Validation<X, A> toValidation(final X x) {
@@ -525,7 +525,7 @@ public static <A, X> F<Option<A>, F<X, Either<X, A>>> toEither() {
    * @return A list projection of this optional value.
    */
   public final List<A> toList() {
-    return isSome() ? cons(some(), List.<A>nil()) : List.<A>nil();
+    return isSome() ? cons(some(), List.nil()) : List.nil();
   }
 
   /**
@@ -534,7 +534,7 @@ public final List<A> toList() {
    * @return A stream projection of this optional value.
    */
   public final Stream<A> toStream() {
-    return isSome() ? Stream.<A>nil().cons(some()) : Stream.<A>nil();
+    return isSome() ? Stream.<A>nil().cons(some()) : Stream.nil();
   }
 
   /**
@@ -544,7 +544,7 @@ public final Stream<A> toStream() {
    */
   @SuppressWarnings("unchecked")
   public final Array<A> toArray() {
-    return isSome() ? Array.array(some()) : Array.<A>empty();
+    return isSome() ? Array.array(some()) : Array.empty();
   }
 
   /**
@@ -609,7 +609,7 @@ public final boolean exists(final F<A, Boolean> f) {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Option.class, this, other, () -> Equal.optionEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Option.class, this, other, () -> Equal.optionEqual(Equal.anyEqual()));
   }
 
   /**
@@ -651,7 +651,7 @@ public static <T> F<T, Option<T>> some_() {
    * @return An optional value that has a value of the given argument.
    */
   public static <T> Option<T> some(final T t) {
-    return new Some<T>(t);
+    return new Some<>(t);
   }
 
   public static <T> F<T, Option<T>> none_() {
@@ -664,7 +664,7 @@ public static <T> F<T, Option<T>> none_() {
    * @return An optional value that has no value.
    */
   public static <T> Option<T> none() {
-    return new None<T>();
+    return new None<>();
   }
 
   /**
@@ -675,7 +675,7 @@ public static <T> Option<T> none() {
    * @return If <code>t == null</code> then return none, otherwise, return it in some.
    */
   public static <T> Option<T> fromNull(final T t) {
-    return t == null ? Option.<T>none() : some(t);
+    return t == null ? Option.none() : some(t);
   }
 
   /**
@@ -707,7 +707,7 @@ public static <A> Option<A> join(final Option<Option<A>> o) {
    */
   public static <A> Option<List<A>> sequence(final List<Option<A>> a) {
     return a.isEmpty() ?
-           some(List.<A>nil()) :
+           some(List.nil()) :
            a.head().bind(aa -> sequence(a.tail()).map(cons_(aa)));
   }
 
@@ -722,7 +722,7 @@ public static <A> Option<List<A>> sequence(final List<Option<A>> a) {
    *         on that argument, otherwise, returns no value.
    */
   public static <A> Option<A> iif(final F<A, Boolean> f, final A a) {
-    return f.f(a) ? some(a) : Option.<A>none();
+    return f.f(a) ? some(a) : Option.none();
   }
 
   /**
@@ -735,7 +735,7 @@ public static <A> Option<A> iif(final F<A, Boolean> f, final A a) {
    *         no value.
    */
   public static <A> Option<A> iif(final boolean p, final F0<A> a) {
-    return p ? some(a.f()) : Option.<A>none();
+    return p ? some(a.f()) : Option.none();
   }
 
   /**
@@ -768,7 +768,7 @@ public static <A> F2<F<A, Boolean>, A, Option<A>> iif() {
    * @return All the values in the given list.
    */
   public static <A> List<A> somes(final List<Option<A>> as) {
-    return as.filter(Option.<A>isSome_()).map(o -> o.some());
+    return as.filter(Option.isSome_()).map(o -> o.some());
   }
 
 
@@ -779,7 +779,7 @@ public static <A> List<A> somes(final List<Option<A>> as) {
    * @return All the values in the given stream.
    */
   public static <A> Stream<A> somes(final Stream<Option<A>> as) {
-    return as.filter(Option.<A>isSome_()).map(o -> o.some());
+    return as.filter(Option.isSome_()).map(o -> o.some());
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Reader.java b/core/src/main/java/fj/data/Reader.java
index 749f4c9b..042db624 100644
--- a/core/src/main/java/fj/data/Reader.java
+++ b/core/src/main/java/fj/data/Reader.java
@@ -20,7 +20,7 @@ public F<A, B> getFunction() {
 	}
 
 	public static <A, B> Reader<A, B> unit(F<A, B> f) {
-		return new Reader<A, B>(f);
+		return new Reader<>(f);
 	}
 
 	public static <A, B> Reader<A, B> constant(B b) {
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index 84b26d6e..c6eb98be 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -22,7 +22,7 @@
 public final class Seq<A> implements Iterable<A> {
   private static final Measured<Integer, Object> ELEM_MEASURED = measured(intAdditionMonoid, Function.constant(1));
   private static final MakeTree<Integer, Object> MK_TREE = FingerTree.mkTree(ELEM_MEASURED);
-  private static final Seq<Object> EMPTY = new Seq<Object>(MK_TREE.empty());
+  private static final Seq<Object> EMPTY = new Seq<>(MK_TREE.empty());
 
   @SuppressWarnings("unchecked")
   private static <A> MakeTree<Integer, A> mkTree() {
@@ -52,7 +52,7 @@ public static <A> Seq<A> empty() {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Seq.class, this, other, () -> Equal.seqEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Seq.class, this, other, () -> Equal.seqEqual(Equal.anyEqual()));
   }
 
   /**
@@ -62,7 +62,7 @@ public boolean equals(Object other) {
    * @return A new sequence with the given element in it.
    */
   public static <A> Seq<A> single(final A a) {
-    return new Seq<A>(Seq.<A>mkTree().single(a));
+    return new Seq<>(Seq.<A>mkTree().single(a));
   }
 
   /**
@@ -146,7 +146,7 @@ public static <A>Seq<A> fromJavaList(final java.util.List<A> list) {
    * @return A new sequence with the given element at the front.
    */
   public Seq<A> cons(final A a) {
-    return new Seq<A>(ftree.cons(a));
+    return new Seq<>(ftree.cons(a));
   }
 
   /**
@@ -156,7 +156,7 @@ public Seq<A> cons(final A a) {
    * @return A new sequence with the given element at the end.
    */
   public Seq<A> snoc(final A a) {
-    return new Seq<A>(ftree.snoc(a));
+    return new Seq<>(ftree.snoc(a));
   }
 
   /**
@@ -263,7 +263,7 @@ public String toString() {
    * @return A new sequence with the given sequence appended to this one.
    */
   public Seq<A> append(final Seq<A> as) {
-    return new Seq<A>(ftree.append(as.ftree));
+    return new Seq<>(ftree.append(as.ftree));
   }
 
   /**
@@ -312,7 +312,7 @@ public P2<Seq<A>, Seq<A>> split(final int i) {
    */
   public A index(final int i) {
     checkBounds(i);
-    return ftree.lookup(Function.<Integer>identity(), i)._2();
+    return ftree.lookup(Function.identity(), i)._2();
   }
 
   /**
@@ -376,7 +376,7 @@ public int hashCode() {
     }
 
     public <B> Seq<B> map(F<A, B> f) {
-        return new Seq<B>(ftree.map(f, Seq.<B>elemMeasured()));
+        return new Seq<>(ftree.map(f, Seq.elemMeasured()));
     }
 
 }
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 4dcd10de..5bb902d6 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -115,20 +115,20 @@ public Set<A> r() {
   public final P2<Boolean, Set<A>> update(final A a, final F<A, A> f) {
     return isEmpty()
            ? P.p(false, this)
-           : tryUpdate(a, f).either(a2 -> P.p(true, delete(a).insert(a2)), Function.<P2<Boolean, Set<A>>>identity());
+           : tryUpdate(a, f).either(a2 -> P.p(true, delete(a).insert(a2)), Function.identity());
   }
 
   private Either<A, P2<Boolean, Set<A>>> tryUpdate(final A a, final F<A, A> f) {
     if (isEmpty())
       return right(P.p(false, this));
     else if (ord.isLessThan(a, head()))
-      return l().tryUpdate(a, f).right().map(set -> set._1() ? P.p(true, (Set<A>) new Tree<A>(ord, color(), set._2(), head(), r())) : set);
+      return l().tryUpdate(a, f).right().map(set -> set._1() ? P.p(true, (Set<A>) new Tree<>(ord, color(), set._2(), head(), r())) : set);
     else if (ord.eq(a, head())) {
       final A h = f.f(head());
       return ord.eq(head(), h) ? Either
-          .<A, P2<Boolean, Set<A>>>right(P.p(true, (Set<A>) new Tree<A>(ord, color(), l(), h, r())))
-                               : Either.<A, P2<Boolean, Set<A>>>left(h);
-    } else return r().tryUpdate(a, f).right().map(set -> set._1() ? P.p(true, (Set<A>) new Tree<A>(ord, color(), l(), head(), set._2())) : set);
+          .right(P.p(true, (Set<A>) new Tree<>(ord, color(), l(), h, r())))
+                               : Either.left(h);
+    } else return r().tryUpdate(a, f).right().map(set -> set._1() ? P.p(true, (Set<A>) new Tree<>(ord, color(), l(), head(), set._2())) : set);
   }
 
   /**
@@ -138,12 +138,12 @@ else if (ord.eq(a, head())) {
    * @return the empty set.
    */
   public static <A> Set<A> empty(final Ord<A> ord) {
-    return new Empty<A>(ord);
+    return new Empty<>(ord);
   }
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Set.class, this, other, () -> Equal.setEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Set.class, this, other, () -> Equal.setEqual(Equal.anyEqual()));
   }
 
   @Override
@@ -197,16 +197,16 @@ public static <A> F<A, F<Set<A>, Set<A>>> insert() {
 
   private Set<A> ins(final A x) {
     return isEmpty()
-           ? new Tree<A>(ord, Color.R, empty(ord), x, empty(ord))
+           ? new Tree<>(ord, Color.R, empty(ord), x, empty(ord))
            : ord.isLessThan(x, head())
              ? balance(ord, color(), l().ins(x), head(), r())
              : ord.eq(x, head())
-               ? new Tree<A>(ord, color(), l(), x, r())
+               ? new Tree<>(ord, color(), l(), x, r())
                : balance(ord, color(), l(), head(), r().ins(x));
   }
 
   private Set<A> makeBlack() {
-    return new Tree<A>(ord, Color.B, l(), head(), r());
+    return new Tree<>(ord, Color.B, l(), head(), r());
   }
 
   @SuppressWarnings("SuspiciousNameCombination")
@@ -214,11 +214,11 @@ private static <A> Tree<A> tr(final Ord<A> o,
                                 final Set<A> a, final A x, final Set<A> b,
                                 final A y,
                                 final Set<A> c, final A z, final Set<A> d) {
-    return new Tree<A>(o, Color.R, new Tree<A>(o, Color.B, a, x, b), y, new Tree<A>(o, Color.B, c, z, d));
+    return new Tree<>(o, Color.R, new Tree<>(o, Color.B, a, x, b), y, new Tree<>(o, Color.B, c, z, d));
   }
 
   private static <A> Set<A> balance(final Ord<A> ord, final Color c, final Set<A> l, final A h, final Set<A> r) {
-    return c == Color.B && l.isTR() && l.l().isTR() ? tr(ord, l.l().l(), l.l().head(), l.l().r(), l.head(), l.r(), h, r) : c == Color.B && l.isTR() && l.r().isTR() ? tr(ord, l.l(), l.head(), l.r().l(), l.r().head(), l.r().r(), h, r) : c == Color.B && r.isTR() && r.l().isTR() ? tr(ord, l, h, r.l().l(), r.l().head(), r.l().r(), r.head(), r.r()) : c == Color.B && r.isTR() && r.r().isTR() ? tr(ord, l, h, r.l(), r.head(), r.r().l(), r.r().head(), r.r().r()) : new Tree<A>(ord, c, l, h, r);
+    return c == Color.B && l.isTR() && l.l().isTR() ? tr(ord, l.l().l(), l.l().head(), l.l().r(), l.head(), l.r(), h, r) : c == Color.B && l.isTR() && l.r().isTR() ? tr(ord, l.l(), l.head(), l.r().l(), l.r().head(), l.r().r(), h, r) : c == Color.B && r.isTR() && r.l().isTR() ? tr(ord, l, h, r.l().l(), r.l().head(), r.l().r(), r.head(), r.r()) : c == Color.B && r.isTR() && r.r().isTR() ? tr(ord, l, h, r.l(), r.head(), r.r().l(), r.r().head(), r.r().r()) : new Tree<>(ord, c, l, h, r);
   }
 
   private boolean isTR() {
@@ -288,7 +288,7 @@ public final <B> B foldMapRight(final F<A, B> f, final Monoid<B> m) {
    * @return a list representation of this set.
    */
   public final List<A> toList() {
-    return foldMap(List.cons(List.<A>nil()), Monoid.<A>listMonoid());
+    return foldMap(List.cons(List.nil()), Monoid.listMonoid());
   }
 
   /**
@@ -306,7 +306,7 @@ public final java.util.Set<A> toJavaSet() {
    * @return a java.util.HashSet representation of this set.
    */
   public final java.util.HashSet<A> toJavaHashSet() {
-    return new java.util.HashSet<A>(toStream().toCollection());
+    return new java.util.HashSet<>(toStream().toCollection());
   }
 
   /**
@@ -315,7 +315,7 @@ public final java.util.HashSet<A> toJavaHashSet() {
    * @return a java.util.TreeSet representation of this set.
    */
   public final java.util.TreeSet<A> toJavaTreeSet() {
-    return new java.util.TreeSet<A>(toStream().toCollection());
+    return new java.util.TreeSet<>(toStream().toCollection());
   }
 
   /**
@@ -324,7 +324,7 @@ public final java.util.TreeSet<A> toJavaTreeSet() {
    * @return a java.util.List representation of this set.
    */
   public final java.util.List toJavaList() {
-    return new java.util.ArrayList<A>(toStream().toCollection());
+    return new java.util.ArrayList<>(toStream().toCollection());
   }
 
   /**
@@ -333,7 +333,7 @@ public final java.util.List toJavaList() {
      * @return a list representation of this set in reverse order.
      */
     public final List<A> toListReverse() {
-        return foldMapRight(List.cons(List.<A>nil()), Monoid.<A>listMonoid());
+        return foldMapRight(List.cons(List.nil()), Monoid.listMonoid());
     }
 
   /**
@@ -500,7 +500,7 @@ public final int size() {
    */
   public final P3<Set<A>, Option<A>, Set<A>> split(final A a) {
     if (isEmpty())
-      return P.p(empty(ord), Option.<A>none(), empty(ord));
+      return P.p(empty(ord), Option.none(), empty(ord));
     else {
       final A h = head();
       final Ordering i = ord.compare(a, h);
@@ -539,7 +539,7 @@ public final boolean subsetOf(final Set<A> s) {
    */
   public static <A> Set<A> join(final Ord<A> o, final Set<Set<A>> s) {
     final F<Set<A>, Set<A>> id = identity();
-    return s.foldMap(id, Monoid.<A>setMonoid(o));
+    return s.foldMap(id, Monoid.setMonoid(o));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 47703e7b..e0724373 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -20,7 +20,7 @@ public P2<S, A> run(S s) {
 	}
 
 	public static <S, A> State<S, A> unit(F<S, P2<S, A>> f) {
-		return new State<S, A>(f);
+		return new State<>(f);
 	}
 
 	public static <S> State<S, S> units(F<S, S> f) {
@@ -102,7 +102,7 @@ public static <S, A> State<S, A> gets(F<S, A> f) {
 	public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
 		return list.foldLeft((State<S, List<A>> acc, State<S, A> ma) ->
 			acc.flatMap((List<A> xs) -> ma.map(xs::snoc)
-		), constant(List.<A>nil()));
+		), constant(List.nil()));
 	}
 
 	/**
@@ -112,7 +112,7 @@ public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
 	public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B>> f) {
 		return list.foldLeft((State<S, List<B>> acc, A a) ->
 			acc.flatMap(bs -> f.f(a).map(bs::snoc)
-		), constant(List.<B>nil()));
+		), constant(List.nil()));
 	}
 
 }
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 8e04e499..4abde573 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -145,7 +145,7 @@ public final <B> B foldRight(final F2<A, P1<B>, B> f, final B b) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight1(final F<A, F<B, B>> f, final B b) {
-    return foldRight(compose(Function.<P1<B>, B, B>andThen().f(P1.<B>__1()), f), b);
+    return foldRight(compose(Function.<P1<B>, B, B>andThen().f(P1.__1()), f), b);
   }
 
   /**
@@ -255,7 +255,7 @@ public Stream<A> prefix(final A x, final Stream<A> xs) {
    * @return A new stream after the given function has been applied to each element.
    */
   public final <B> Stream<B> map(final F<A, B> f) {
-    return isEmpty() ? Stream.<B>nil() : cons(f.f(head()), () -> tail()._1().map(f));
+    return isEmpty() ? Stream.nil() : cons(f.f(head()), () -> tail()._1().map(f));
   }
 
   /**
@@ -353,7 +353,7 @@ public final Stream<A> removeAll(final F<A, Boolean> f) {
    */
   public static <A, B> F<B, Stream<A>> sequence_(final Stream<F<B, A>> fs) {
     return fs.foldRight((baf, p1) -> Function.bind(baf, p1._1(), curry((a, stream) -> cons(a, p(stream)))), Function
-            .<B, Stream<A>>constant(Stream.<A>nil()));
+            .constant(Stream.nil()));
   }
 
   /**
@@ -580,7 +580,7 @@ public static <A> Stream<A> enumerationStream(Enumeration<A> e) {
    * @return A new stream with the elements of this stream sorted according to the given ordering.
    */
   public final Stream<A> sort(final Ord<A> o) {
-    return mergesort(o, map(flip(Stream.<A>cons()).f(p(Stream.<A>nil()))));
+    return mergesort(o, map(flip(Stream.<A>cons()).f(p(Stream.nil()))));
   }
 
   // Merges a stream of individually sorted streams into a single sorted stream.
@@ -700,7 +700,7 @@ public int size() {
    *         <code>to</code> value (exclusive).
    */
   public static Stream<Integer> range(final int from, final long to) {
-    return from >= to ? Stream.<Integer>nil() : cons(from, () -> range(from + 1, to));
+    return from >= to ? Stream.nil() : cons(from, () -> range(from + 1, to));
   }
 
   /**
@@ -768,7 +768,7 @@ public static <A> Stream<A> forever(final Enumerator<A> e, final A from) {
    *         given value and stepping at the given increment.
    */
   public static <A> Stream<A> forever(final Enumerator<A> e, final A from, final long step) {
-    return cons(from, () -> e.plus(from, step).map(a -> forever(e, a, step)).orSome(Stream.<A>nil()));
+    return cons(from, () -> e.plus(from, step).map(a -> forever(e, a, step)).orSome(Stream.nil()));
   }
 
   /**
@@ -830,7 +830,7 @@ public static <A> F<F<A, Boolean>, F<Stream<A>, Stream<A>>> filter() {
    * @return A new stream with a length the same as the shortest of this stream and the given stream.
    */
   public final <B> Stream<B> zapp(final Stream<F<A, B>> fs) {
-    return fs.isEmpty() || isEmpty() ? Stream.<B>nil() :
+    return fs.isEmpty() || isEmpty() ? Stream.nil() :
            cons(fs.head().f(head()), () -> tail()._1().zapp(fs.tail()._1()));
   }
 
@@ -904,7 +904,7 @@ public final Stream<P2<A, Integer>> zipIndex() {
    * @return An either projection of this stream.
    */
   public final <X> Either<X, A> toEither(final F0<X> x) {
-    return isEmpty() ? Either.<X, A>left(x.f()) : Either.<X, A>right(head());
+    return isEmpty() ? Either.left(x.f()) : Either.right(head());
   }
 
   /**
@@ -914,7 +914,7 @@ public final <X> Either<X, A> toEither(final F0<X> x) {
    * @return An option projection of this stream.
    */
   public final Option<A> toOption() {
-    return isEmpty() ? Option.<A>none() : some(head());
+    return isEmpty() ? Option.none() : some(head());
   }
 
   /**
@@ -950,7 +950,7 @@ public final List<A> toList() {
    * Returns a java.util.List projection of this stream.
    */
   public final java.util.List<A> toJavaList() {
-    return new java.util.LinkedList<A>(toCollection());
+    return new java.util.LinkedList<>(toCollection());
   }
 
   /**
@@ -1007,7 +1007,7 @@ public final A[] array(final Class<A[]> c) {
    * @return A new stream with the given element at the head.
    */
   public final Stream<A> cons(final A a) {
-    return new Cons<A>(a, () -> Stream.this);
+    return new Cons<>(a, () -> Stream.this);
   }
 
   /**
@@ -1062,8 +1062,8 @@ public final Stream<A> snoc(final F0<A> a) {
    */
   public final Stream<A> take(final int n) {
     return n <= 0 || isEmpty() ?
-           Stream.<A>nil() :
-           cons(head(), () -> n <= 1 ? Stream.<A>nil() : tail()._1().take(n - 1));
+           Stream.nil() :
+           cons(head(), () -> n <= 1 ? Stream.nil() : tail()._1().take(n - 1));
   }
 
   /**
@@ -1093,7 +1093,7 @@ public final Stream<A> takeWhile(final F<A, Boolean> f) {
            this :
            f.f(head()) ?
            cons(head(), () -> tail()._1().takeWhile(f)) :
-           Stream.<A>nil();
+           Stream.nil();
   }
 
   /**
@@ -1104,7 +1104,7 @@ public final Stream<A> takeWhile(final F<A, Boolean> f) {
   public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
     return this.foldRight1((a, acc) ->
             IOFunctions.bind(acc, (Stream<B> bs) ->
-                    IOFunctions.map(f.f(a), bs::cons)), IOFunctions.unit(Stream.<B>nil()));
+                    IOFunctions.map(f.f(a), bs::cons)), IOFunctions.unit(Stream.nil()));
 
   }
 
@@ -1114,7 +1114,7 @@ public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
    * @return traversed value
    */
   public final <B> Option<Stream<B>> traverseOption(F<A, Option<B>> f) {
-    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(bs::cons)), some(Stream.<B>nil()));
+    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(bs::cons)), some(Stream.nil()));
   }
 
   /**
@@ -1146,11 +1146,11 @@ public final P2<Stream<A>, Stream<A>> span(final F<A, Boolean> p) {
     else if (p.f(head())) {
       final P1<P2<Stream<A>, Stream<A>>> yszs = P.lazy(() -> tail()._1().span(p));
       return P.lazy(
-            () -> cons(head(), yszs.map(P2.<Stream<A>, Stream<A>>__1())),
+            () -> cons(head(), yszs.map(P2.__1())),
             () -> yszs._1()._2()
         );
     } else
-      return p(Stream.<A>nil(), this);
+      return p(Stream.nil(), this);
   }
 
   /**
@@ -1187,7 +1187,7 @@ public final P2<Stream<A>, Stream<A>> split(final F<A, Boolean> p) {
    * @return A new stream that is the reverse of this one.
    */
   public final Stream<A> reverse() {
-    return foldLeft(as -> a -> cons(a, () -> as), Stream.<A>nil());
+    return foldLeft(as -> a -> cons(a, () -> as), Stream.nil());
   }
 
   /**
@@ -1259,7 +1259,7 @@ public final boolean forall(final F<A, Boolean> f) {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Stream.class, this, other, () -> Equal.streamEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Stream.class, this, other, () -> Equal.streamEqual(Equal.anyEqual()));
   }
 
   @Override
@@ -1325,7 +1325,7 @@ public final <B> Stream<B> cobind(final F<Stream<A>, B> k) {
    * @return a stream of the suffixes of this stream, starting with the stream itself.
    */
   public final Stream<Stream<A>> tails() {
-    return isEmpty() ? Stream.<Stream<A>>nil() : cons(this, () -> tail()._1().tails());
+    return isEmpty() ? Stream.nil() : cons(this, () -> tail()._1().tails());
   }
 
   /**
@@ -1334,7 +1334,7 @@ public final Stream<Stream<A>> tails() {
    * @return a stream of the prefixes of this stream, starting with the stream itself.
    */
   public final Stream<Stream<A>> inits() {
-    final Stream<Stream<A>> nil = cons(Stream.<A>nil(), Stream::nil);
+    final Stream<Stream<A>> nil = cons(Stream.nil(), Stream::nil);
     return isEmpty() ? nil : nil.append(() -> tail()._1().inits().map(Stream.<A>cons_().f(head())));
   }
 
@@ -1354,7 +1354,7 @@ public final Stream<Stream<A>> substreams() {
    * @return the position of the first element matching the given predicate, if any.
    */
   public final Option<Integer> indexOf(final F<A, Boolean> p) {
-    return zipIndex().find(p2 -> p.f(p2._1())).map(P2.<A, Integer>__2());
+    return zipIndex().find(p2 -> p.f(p2._1())).map(P2.__2());
   }
 
   /**
@@ -1365,7 +1365,7 @@ public final Option<Integer> indexOf(final F<A, Boolean> p) {
    */
   public final <B> Stream<B> sequenceW(final Stream<F<Stream<A>, B>> fs) {
     return fs.isEmpty()
-           ? Stream.<B>nil()
+           ? Stream.nil()
            : cons(fs.head().f(this), () -> sequenceW(fs.tail()._1()));
   }
 
@@ -1403,7 +1403,7 @@ public static <A, B> Stream<A> fromFunction(final Enumerator<B> e, final F<B, A>
         final Option<B> s = e.successor(i);
         return s.isSome()
                ? fromFunction(e, f, s.some())
-               : Stream.<A>nil();
+               : Stream.nil();
       });
   }
 
@@ -1417,7 +1417,7 @@ public static <A, B> P2<Stream<A>, Stream<B>> unzip(final Stream<P2<A, B>> xs) {
     return xs.foldRight((p, ps) -> {
       final P2<Stream<A>, Stream<B>> pp = ps._1();
       return p(cons(p._1(), p(pp._1())), cons(p._2(), p(pp._2())));
-    }, p(Stream.<A>nil(), Stream.<B>nil()));
+    }, p(Stream.nil(), Stream.nil()));
   }
 
   /**
@@ -1482,7 +1482,7 @@ public static <A> F<A, F<Stream<A>, Stream<A>>> cons_() {
    * @return An empty stream.
    */
   public static <A> Stream<A> nil() {
-    return new Nil<A>();
+    return new Nil<>();
   }
 
   /**
@@ -1539,7 +1539,7 @@ public static <A> F<A, Stream<A>> single() {
    * @return The stream with the given element prepended.
    */
   public static <A> Stream<A> cons(final A head, final F0<Stream<A>> tail) {
-    return new Cons<A>(head, tail);
+    return new Cons<>(head, tail);
   }
 
   /**
@@ -1605,8 +1605,8 @@ public static <A> Stream<A> iterableStream(final Iterable<A> i) {
 
   @SafeVarargs
   public static <A> Stream<A> arrayStream(final A...as) {
-    return as.length == 0 ? Stream.<A>nil()
-            : unfold(P2.tuple((as1, i) -> i >= as.length ? Option.<P2<A, P2<A[], Integer>>>none()
+    return as.length == 0 ? Stream.nil()
+            : unfold(P2.tuple((as1, i) -> i >= as.length ? Option.none()
             : some(p(as[i], p(as, i + 1)))), p(as, 0));
   }
 
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index 82e682bc..4b0ce7eb 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -38,7 +38,7 @@ private Tree(final A root, final P1<Stream<Tree<A>>> subForest) {
    * @return A nullary tree with the root element in it.
    */
   public static <A> Tree<A> leaf(final A root) {
-    return node(root, Stream.<Tree<A>>nil());
+    return node(root, Stream.nil());
   }
 
   /**
@@ -49,7 +49,7 @@ public static <A> Tree<A> leaf(final A root) {
    * @return A newly sprouted tree.
    */
   public static <A> Tree<A> node(final A root, final P1<Stream<Tree<A>>> forest) {
-    return new Tree<A>(root, forest);
+    return new Tree<>(root, forest);
   }
 
   /**
@@ -60,7 +60,7 @@ public static <A> Tree<A> node(final A root, final P1<Stream<Tree<A>>> forest) {
    * @return A newly sprouted tree.
    */
   public static <A> Tree<A> node(final A root, final Stream<Tree<A>> forest) {
-    return new Tree<A>(root, P.p(forest));
+    return new Tree<>(root, P.p(forest));
   }
 
   /**
@@ -130,7 +130,7 @@ public Stream<A> f(final Tree<A> t, final P1<Stream<A>> xs) {
         return cons(t.root(), t.subForest().map(Stream.<Tree<A>, Stream<A>>foldRight().f(F2Functions.curry(this)).f(xs._1())));
       }
     };
-    return squish.f(this, P.p(Stream.<A>nil()));
+    return squish.f(this, P.p(Stream.nil()));
   }
 
   /**
@@ -152,9 +152,9 @@ public static <A> F<Tree<A>, Stream<A>> flatten_() {
    */
   public Stream<Stream<A>> levels() {
     final F<Stream<Tree<A>>, Stream<Tree<A>>> flatSubForests =
-        Stream.<Tree<A>, Tree<A>>bind_().f(compose(P1.<Stream<Tree<A>>>__1(), Tree.<A>subForest_()));
-    final F<Stream<Tree<A>>, Stream<A>> roots = Stream.<Tree<A>, A>map_().f(Tree.<A>root_());
-    return iterateWhile(flatSubForests, Stream.<Tree<A>>isNotEmpty_(), single(this)).map(roots);
+        Stream.<Tree<A>, Tree<A>>bind_().f(compose(P1.__1(), Tree.subForest_()));
+    final F<Stream<Tree<A>>, Stream<A>> roots = Stream.<Tree<A>, A>map_().f(Tree.root_());
+    return iterateWhile(flatSubForests, Stream.isNotEmpty_(), single(this)).map(roots);
   }
 
   /**
@@ -245,7 +245,7 @@ public Tree<Tree<A>> cojoin() {
   }
 
   private static <A> Stream<String> drawSubTrees(final Show<A> s, final Stream<Tree<A>> ts) {
-    return ts.isEmpty() ? Stream.<String>nil()
+    return ts.isEmpty() ? Stream.nil()
                         : ts.tail()._1().isEmpty() ? shift("`- ", "   ", ts.head().drawTree(s)).cons("|")
                                                    : shift("+- ", "|  ", ts.head().drawTree(s))
                                                        .append(drawSubTrees(s, ts.tail()._1()));
@@ -261,7 +261,7 @@ private Stream<String> drawTree(final Show<A> s) {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Tree.class, this, other, () -> Equal.treeEqual(Equal.<A>anyEqual()));
+    return Equal.equals0(Tree.class, this, other, () -> Equal.treeEqual(Equal.anyEqual()));
   }
 
   @Override
@@ -328,7 +328,7 @@ public <B, C> Tree<C> zipWith(final Tree<B> bs, final F<A, F<B, C>> f) {
   public static <A, B> Tree<B> bottomUp(Tree<A> t, final F<P2<A, Stream<B>>, B> f) {
     final F<Tree<A>, Tree<B>> recursiveCall = a -> bottomUp(a, f);
     final Stream<Tree<B>> tbs = t.subForest()._1().map(recursiveCall);
-    return node(f.f(P.p(t.root(), tbs.map(Tree.<B> getRoot()))), tbs);
+    return node(f.f(P.p(t.root(), tbs.map(Tree.getRoot()))), tbs);
    }
  
    /**
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index de4876ec..f663ab09 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -31,7 +31,7 @@ private TreeMap(final Set<P2<K, Option<V>>> tree) {
   }
 
   private static <K, V> Ord<P2<K, V>> ord(final Ord<K> keyOrd) {
-    return keyOrd.contramap(P2.<K, V>__1());
+    return keyOrd.contramap(P2.__1());
   }
 
   /**
@@ -41,12 +41,12 @@ private static <K, V> Ord<P2<K, V>> ord(final Ord<K> keyOrd) {
    * @return an empty TreeMap with the given key order.
    */
   public static <K, V> TreeMap<K, V> empty(final Ord<K> keyOrd) {
-    return new TreeMap<K, V>(Set.empty(TreeMap.<K, Option<V>>ord(keyOrd)));
+    return new TreeMap<>(Set.empty(TreeMap.ord(keyOrd)));
   }
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(TreeMap.class, this, other, () -> Equal.treeMapEqual(Equal.<K>anyEqual(), Equal.<V>anyEqual()));
+    return Equal.equals0(TreeMap.class, this, other, () -> Equal.treeMapEqual(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
@@ -129,8 +129,8 @@ public static <K, V> TreeMap<K, V> arrayTreeMap(final Ord<K> keyOrd, final P2<K,
    * @return A potential value for the given key.
    */
   public Option<V> get(final K k) {
-    final Option<P2<K, Option<V>>> x = tree.split(p(k, Option.<V>none()))._2();
-    return x.bind(P2.<K, Option<V>>__2());
+    final Option<P2<K, Option<V>>> x = tree.split(p(k, Option.none()))._2();
+    return x.bind(P2.__2());
   }
 
   /**
@@ -142,7 +142,7 @@ public Option<V> get(final K k) {
    * @return A new tree map with the given value mapped to the given key.
    */
   public TreeMap<K, V> set(final K k, final V v) {
-      return new TreeMap<K, V>(tree.insert(p(k, Option.some(v))));
+      return new TreeMap<>(tree.insert(p(k, Option.some(v))));
   }
 
   /**
@@ -152,7 +152,7 @@ public TreeMap<K, V> set(final K k, final V v) {
    * @return A new tree map with the entry corresponding to the given key removed.
    */
   public TreeMap<K, V> delete(final K k) {
-    return new TreeMap<K, V>(tree.delete(p(k, Option.<V>none())));
+    return new TreeMap<>(tree.delete(p(k, Option.none())));
   }
 
   /**
@@ -179,7 +179,7 @@ public boolean isEmpty() {
    * @return All values in this tree map.
    */
   public List<V> values() {
-    return iterableList(join(tree.toList().map(compose(IterableW.<V, Option<V>>wrap(), P2.<K, Option<V>>__2()))));
+    return iterableList(join(tree.toList().map(compose(IterableW.wrap(), P2.__2()))));
   }
 
   /**
@@ -188,7 +188,7 @@ public List<V> values() {
    * @return All keys in this tree map.
    */
   public List<K> keys() {
-    return tree.toList().map(P2.<K, Option<V>>__1());
+    return tree.toList().map(P2.__1());
   }
 
   /**
@@ -198,7 +198,7 @@ public List<K> keys() {
    * @return <code>true</code> if this tree map contains the given key, <code>false</code> otherwise.
    */
   public boolean contains(final K k) {
-    return tree.member(p(k, Option.<V>none()));
+    return tree.member(p(k, Option.none()));
   }
 
   /**
@@ -208,8 +208,8 @@ public boolean contains(final K k) {
    * @return A iterator for this map's key-value pairs.
    */
   public Iterator<P2<K, V>> iterator() {
-    return join(tree.toStream().map(P2.<K, Option<V>, IterableW<V>>map2_(IterableW.<V, Option<V>>wrap())
-    ).map(P2.tuple(compose(IterableW.<V, P2<K, V>>map(), P.<K, V>p2())))).iterator();
+    return join(tree.toStream().map(P2.map2_(IterableW.wrap())
+    ).map(P2.tuple(compose(IterableW.map(), P.p2())))).iterator();
   }
 
   /**
@@ -220,7 +220,7 @@ public Iterator<P2<K, V>> iterator() {
   public Map<K, V> toMutableMap() {
     final F<K, P2<K, Option<V>>> fakePair = k -> p(k, Option.none());
 	final Comparator<K> comparator = tree.ord().contramap(fakePair).toComparator();
-	final Map<K, V> m = new java.util.TreeMap<K, V>(comparator);
+	final Map<K, V> m = new java.util.TreeMap<>(comparator);
     for (final P2<K, V> e : this) {
       m.put(e._1(), e._2());
     }
@@ -277,8 +277,8 @@ public F<K, Option<V>> get() {
    */
   public P2<Boolean, TreeMap<K, V>> update(final K k, final F<V, V> f) {
     final P2<Boolean, Set<P2<K, Option<V>>>> up =
-        tree.update(p(k, Option.<V>none()), compose(P2.tuple(P.p2()), P2.<K, Option<V>, Option<V>>map2_(Option.<V, V>map().f(f))));
-    return p(up._1(), new TreeMap<K, V>(up._2()));
+        tree.update(p(k, Option.none()), compose(P2.tuple(P.p2()), P2.map2_(Option.<V, V>map().f(f))));
+    return p(up._1(), new TreeMap<>(up._2()));
   }
 
   /**
@@ -309,9 +309,9 @@ public TreeMap<K, V> update(final K k, final F<V, V> f, final V v) {
    *         and the optional value is the value associated with the given key if present, otherwise None.
    */
   public P3<Set<V>, Option<V>, Set<V>> split(Ord<V> ord, final K k) {
-    final F<Set<P2<K, Option<V>>>, Set<V>> getSome = F1Functions.mapSet(F1Functions.o(Option.<V>fromSome(), P2.<K, Option<V>>__2()), ord);
-    return tree.split(p(k, Option.<V>none())).map1(getSome).map3(getSome)
-        .map2(F1Functions.o(Option.<V>join(), F1Functions.mapOption(P2.<K, Option<V>>__2())));
+    final F<Set<P2<K, Option<V>>>, Set<V>> getSome = F1Functions.mapSet(F1Functions.o(Option.fromSome(), P2.__2()), ord);
+    return tree.split(p(k, Option.none())).map1(getSome).map3(getSome)
+        .map2(F1Functions.o(Option.join(), F1Functions.mapOption(P2.__2())));
   }
 
   /**
@@ -321,7 +321,7 @@ public P3<Set<V>, Option<V>, Set<V>> split(Ord<V> ord, final K k) {
    * @return a TreeMap with the given elements.
    */
   private static <K, V> TreeMap<K, V> treeMap(Ord<K> ord, Set<P2<K, Option<V>>> s) {
-    TreeMap<K, V> empty = TreeMap.<K, V>empty(ord);
+    TreeMap<K, V> empty = TreeMap.empty(ord);
     TreeMap<K, V> tree = s.toList().foldLeft((tm, p2) -> {
       Option<V> opt = p2._2();
       if (opt.isSome()) {
@@ -348,7 +348,7 @@ private static <K, V> TreeMap<K, V> treeMap(Ord<K> ord, Set<P2<K, Option<V>>> s)
    */
   public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
     P3<Set<P2<K, Option<V>>>, Option<P2<K, Option<V>>>, Set<P2<K, Option<V>>>> p3 = tree.split(p(k, get(k)));
-    Ord<K> o = tree.ord().<K>contramap(k2 -> p(k2, Option.<V>none()));
+    Ord<K> o = tree.ord().contramap(k2 -> p(k2, Option.none()));
     return p(treeMap(o, p3._1()), get(k), treeMap(o, p3._3()));
   }
 
@@ -361,9 +361,9 @@ public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
   @SuppressWarnings("unchecked")
   public <W> TreeMap<K, W> map(final F<V, W> f) {
     final F<P2<K, Option<V>>, P2<K, Option<W>>> g = P2.map2_(F1Functions.mapOption(f));
-    final F<K, P2<K, Option<V>>> coord = flip(P.<K, Option<V>>p2()).f(Option.<V>none());
+    final F<K, P2<K, Option<V>>> coord = flip(P.<K, Option<V>>p2()).f(Option.none());
     final Ord<K> o = tree.ord().contramap(coord);
-    return new TreeMap<K, W>(tree.map(TreeMap.<K, Option<W>>ord(o), g));
+    return new TreeMap<>(tree.map(TreeMap.ord(o), g));
   }
 
     /**
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index a9d92b5a..c94287cf 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -68,7 +68,7 @@ public static <A> TreeZipper<A> treeZipper(final Tree<A> tree,
                                              final Stream<Tree<A>> lefts,
                                              final Stream<Tree<A>> rights,
                                              final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents) {
-    return new TreeZipper<A>(tree, lefts, rights, parents);
+    return new TreeZipper<>(tree, lefts, rights, parents);
   }
 
   /**
@@ -114,7 +114,7 @@ public static <A> Equal<TreeZipper<A>> eq(final Equal<A> e) {
         treeEqual(e),
         streamEqual(treeEqual(e)),
         streamEqual(treeEqual(e)),
-        streamEqual(p3Equal(streamEqual(treeEqual(e)), e, streamEqual(treeEqual(e))))).contramap(TreeZipper.<A>p_());
+        streamEqual(p3Equal(streamEqual(treeEqual(e)), e, streamEqual(treeEqual(e))))).contramap(TreeZipper.p_());
   }
 
   /**
@@ -128,13 +128,13 @@ public static <A> Show<TreeZipper<A>> show(final Show<A> s) {
         treeShow(s),
         streamShow(treeShow(s)),
         streamShow(treeShow(s)),
-        streamShow(p3Show(streamShow(treeShow(s)), s, streamShow(treeShow(s))))).contramap(TreeZipper.<A>p_());
+        streamShow(p3Show(streamShow(treeShow(s)), s, streamShow(treeShow(s))))).contramap(TreeZipper.p_());
   }
 
   private static <A> Stream<Tree<A>> combChildren(final Stream<Tree<A>> ls,
                                                   final Tree<A> t,
                                                   final Stream<Tree<A>> rs) {
-    return ls.foldLeft(compose(flip(Stream.<Tree<A>>cons()), P.<Stream<Tree<A>>>p1()), Stream.cons(t, P.p(rs)));
+    return ls.foldLeft(compose(flip(Stream.cons()), P.p1()), Stream.cons(t, P.p(rs)));
   }
 
   /**
@@ -158,7 +158,7 @@ public Option<TreeZipper<A>> parent() {
    * @return A new tree zipper focused on the top-most parent of the current node.
    */
   public TreeZipper<A> root() {
-    return parent().option(this, TreeZipper.<A>root_());
+    return parent().option(this, TreeZipper.root_());
   }
 
   /**
@@ -177,7 +177,7 @@ public static <A> F<TreeZipper<A>, TreeZipper<A>> root_() {
    *         or none if there are no siblings on the left.
    */
   public Option<TreeZipper<A>> left() {
-    return lefts.isEmpty() ? Option.<TreeZipper<A>>none()
+    return lefts.isEmpty() ? Option.none()
                            : some(treeZipper(lefts.head(), lefts.tail()._1(), rights.cons(tree), parents));
   }
 
@@ -188,7 +188,7 @@ public Option<TreeZipper<A>> left() {
    *         or none if there are no siblings on the right.
    */
   public Option<TreeZipper<A>> right() {
-    return rights.isEmpty() ? Option.<TreeZipper<A>>none()
+    return rights.isEmpty() ? Option.none()
                             : some(treeZipper(rights.head(), lefts.cons(tree), rights.tail()._1(), parents));
   }
 
@@ -199,8 +199,8 @@ public Option<TreeZipper<A>> right() {
    */
   public Option<TreeZipper<A>> firstChild() {
     final Stream<Tree<A>> ts = tree.subForest()._1();
-    return ts.isEmpty() ? Option.<TreeZipper<A>>none()
-                        : some(treeZipper(ts.head(), Stream.<Tree<A>>nil(), ts.tail()._1(), downParents()));
+    return ts.isEmpty() ? Option.none()
+                        : some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), downParents()));
   }
 
   /**
@@ -210,8 +210,8 @@ public Option<TreeZipper<A>> firstChild() {
    */
   public Option<TreeZipper<A>> lastChild() {
     final Stream<Tree<A>> ts = tree.subForest()._1().reverse();
-    return ts.isEmpty() ? Option.<TreeZipper<A>>none()
-                        : some(treeZipper(ts.head(), ts.tail()._1(), Stream.<Tree<A>>nil(), downParents()));
+    return ts.isEmpty() ? Option.none()
+                        : some(treeZipper(ts.head(), ts.tail()._1(), Stream.nil(), downParents()));
   }
 
   /**
@@ -223,7 +223,7 @@ public Option<TreeZipper<A>> lastChild() {
   public Option<TreeZipper<A>> getChild(final int n) {
     Option<TreeZipper<A>> r = none();
     for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
-        : splitChildren(Stream.<Tree<A>>nil(), tree.subForest()._1(), n)) {
+        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
       r = some(treeZipper(lr._1().head(), lr._1().tail()._1(), lr._2(), downParents()));
     }
     return r;
@@ -246,14 +246,14 @@ public Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>> f(final Stream<Tree
             return xs.isNotEmpty()
                      ? p.f(xs.head()) ? some(P.p(acc, xs.head(), xs.tail()._1()))
                                       : f(acc.cons(xs.head()), xs.tail()._1())
-                     : Option.<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>>none();
+                     : Option.none();
           }
         };
 
     Stream<Tree<A>> subforest = tree.subForest()._1();
     if (subforest.isNotEmpty()) {
       for (final P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>> ltr
-        : split.f(Stream.<Tree<A>>nil(), subforest)) {
+        : split.f(Stream.nil(), subforest)) {
         r = some(treeZipper(ltr._2(), ltr._1(), ltr._3(), downParents()));
       }
     }
@@ -269,7 +269,7 @@ private static <A> Option<P2<Stream<A>, Stream<A>>> splitChildren(final Stream<A
                                                                     final int n) {
     return n == 0 ? some(P.p(acc, xs))
                   : xs.isNotEmpty() ? splitChildren(acc.cons(xs.head()), xs.tail()._1(), n - 1)
-                                    : Option.<P2<Stream<A>, Stream<A>>>none();
+                                    : Option.none();
   }
 
   private static <A> Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> lp3nil() {
@@ -283,7 +283,7 @@ private static <A> Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> lp3nil() {
    * @return a new tree zipper focused on the root of the given tree.
    */
   public static <A> TreeZipper<A> fromTree(final Tree<A> t) {
-    return treeZipper(t, Stream.<Tree<A>>nil(), Stream.<Tree<A>>nil(), TreeZipper.<A>lp3nil());
+    return treeZipper(t, Stream.nil(), Stream.nil(), TreeZipper.lp3nil());
   }
 
   /**
@@ -294,8 +294,8 @@ public static <A> TreeZipper<A> fromTree(final Tree<A> t) {
    */
   public static <A> Option<TreeZipper<A>> fromForest(final Stream<Tree<A>> ts) {
     return ts.isNotEmpty()
-           ? some(treeZipper(ts.head(), Stream.<Tree<A>>nil(), ts.tail()._1(), TreeZipper.<A>lp3nil()))
-           : Option.<TreeZipper<A>>none();
+           ? some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), TreeZipper.lp3nil()))
+           : Option.none();
   }
 
   /**
@@ -474,7 +474,7 @@ public TreeZipper<A> insertRight(final Tree<A> t) {
    * @return A new tree zipper with the given tree in focus, as the first child of the current node.
    */
   public TreeZipper<A> insertDownFirst(final Tree<A> t) {
-    return treeZipper(t, Stream.<Tree<A>>nil(), tree.subForest()._1(), downParents());
+    return treeZipper(t, Stream.nil(), tree.subForest()._1(), downParents());
   }
 
   /**
@@ -484,7 +484,7 @@ public TreeZipper<A> insertDownFirst(final Tree<A> t) {
    * @return A new tree zipper with the given tree in focus, as the last child of the current node.
    */
   public TreeZipper<A> insertDownLast(final Tree<A> t) {
-    return treeZipper(t, tree.subForest()._1().reverse(), Stream.<Tree<A>>nil(), downParents());
+    return treeZipper(t, tree.subForest()._1().reverse(), Stream.nil(), downParents());
   }
 
   /**
@@ -499,7 +499,7 @@ public TreeZipper<A> insertDownLast(final Tree<A> t) {
   public Option<TreeZipper<A>> insertDownAt(final int n, final Tree<A> t) {
     Option<TreeZipper<A>> r = none();
     for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
-        : splitChildren(Stream.<Tree<A>>nil(), tree.subForest()._1(), n)) {
+        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
       r = some(treeZipper(t, lr._1(), lr._2(), downParents()));
     }
     return r;
@@ -518,7 +518,7 @@ public Option<TreeZipper<A>> delete() {
     else if (lefts.isNotEmpty())
       r = some(treeZipper(lefts.head(), lefts.tail()._1(), rights, parents));
     else for (final TreeZipper<A> loc : parent())
-        r = some(loc.modifyTree(t -> node(t.root(), Stream.<Tree<A>>nil())));
+        r = some(loc.modifyTree(t -> node(t.root(), Stream.nil())));
     return r;
   }
 
@@ -531,7 +531,7 @@ else for (final TreeZipper<A> loc : parent())
    */
   public TreeZipper<P2<A, Boolean>> zipWithFocus() {
     final F<A, P2<A, Boolean>> f = flip(P.<A, Boolean>p2()).f(false);
-    return map(f).modifyLabel(P2.<A, Boolean, Boolean>map2_(Booleans.not));
+    return map(f).modifyLabel(P2.map2_(Booleans.not));
   }
 
   /**
@@ -582,15 +582,15 @@ public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> right_() {
    */
   public TreeZipper<TreeZipper<A>> positions() {
     final Tree<TreeZipper<A>> t = unfoldTree(TreeZipper.<A>dwn()).f(this);
-    final Stream<Tree<TreeZipper<A>>> l = uf(TreeZipper.<A>left_());
-    final Stream<Tree<TreeZipper<A>>> r = uf(TreeZipper.<A>right_());
+    final Stream<Tree<TreeZipper<A>>> l = uf(TreeZipper.left_());
+    final Stream<Tree<TreeZipper<A>>> r = uf(TreeZipper.right_());
     final Stream<P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>> p = unfold(
         o -> {
           Option<P2<
               P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
               Option<TreeZipper<A>>>> r1 = none();
           for (final TreeZipper<A> z : o) {
-            r1 = some(P.p(P.p(z.uf(TreeZipper.<A>left_()), z, z.uf(TreeZipper.<A>right_())), z.parent()));
+            r1 = some(P.p(P.p(z.uf(TreeZipper.left_()), z, z.uf(TreeZipper.right_())), z.parent()));
           }
           return r1;
         }, parent());
@@ -609,7 +609,7 @@ private Stream<Tree<TreeZipper<A>>> uf(final F<TreeZipper<A>, Option<TreeZipper<
   }
 
   private static <A> F<TreeZipper<A>, P2<TreeZipper<A>, P1<Stream<TreeZipper<A>>>>> dwn() {
-    return tz -> P.<TreeZipper<A>, P1<Stream<TreeZipper<A>>>>p(tz, new P1<Stream<TreeZipper<A>>>() {
+    return tz -> P.p(tz, new P1<Stream<TreeZipper<A>>>() {
       private F<Option<TreeZipper<A>>, Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>>> fwd() {
         return o -> {
           Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>> r = none();
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 8328590f..9d82596b 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -175,8 +175,8 @@ public void foreachDoEffect(final Effect1<T> f) {
   @SuppressWarnings("unchecked")
   public <A> Validation<E, A> map(final F<T, A> f) {
     return isFail() ?
-        Validation.<E, A>fail(fail()) :
-        Validation.<E, A>success(f.f(success()));
+        Validation.fail(fail()) :
+        Validation.success(f.f(success()));
   }
 
   /**
@@ -187,7 +187,7 @@ public <A> Validation<E, A> map(final F<T, A> f) {
    */
   @SuppressWarnings("unchecked")
   public <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
-    return isSuccess() ? f.f(success()) : Validation.<E, A>fail(fail());
+    return isSuccess() ? f.f(success()) : Validation.fail(fail());
   }
 
   /**
@@ -197,7 +197,7 @@ public <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
    * @return A validation after binding.
    */
   public <A> Validation<E, A> sequence(final Validation<E, A> v) {
-    return bind(Function.<T, Validation<E, A>>constant(v));
+    return bind(Function.constant(v));
   }
 
   /**
@@ -206,7 +206,7 @@ public <A> Validation<E, A> sequence(final Validation<E, A> v) {
    */
   public static <E, A> Validation<E, List<A>> sequence(final Semigroup<E> s, final List<Validation<E, A>> list) {
     if (list.exists(Validation::isFail)) {
-      return Validation.<E, List<A>>fail(list.filter(Validation::isFail).map(v -> v.fail()).foldLeft1((F2<E, E, E>) s::sum));
+      return Validation.fail(list.filter(Validation::isFail).map(v -> v.fail()).foldLeft1((F2<E, E, E>) s::sum));
     } else {
       return success(list.foldLeft((List<A> acc, Validation<E, A> v) -> acc.cons(v.success()), List.nil()).reverse());
     }
@@ -221,7 +221,7 @@ public static <E, A> Validation<E, List<A>> sequence(final Semigroup<E> s, final
    *         success value, otherwise, returns a success in <code>Some</code>.
    */
   public <A> Option<Validation<A, T>> filter(final F<T, Boolean> f) {
-    return e.right().<A>filter(f).map(Validation.<A, T>validation());
+    return e.right().<A>filter(f).map(Validation.validation());
   }
 
   /**
@@ -260,7 +260,7 @@ public boolean exists(final F<T, Boolean> f) {
 
   @Override
   public boolean equals(Object other) {
-    return Equal.equals0(Validation.class, this, other, () -> Equal.validationEqual(Equal.<E>anyEqual(), Equal.<T>anyEqual()));
+    return Equal.equals0(Validation.class, this, other, () -> Equal.validationEqual(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
@@ -316,12 +316,12 @@ public Stream<T> toStream() {
   @SuppressWarnings("unchecked")
   public <A> Validation<E, A> accumapply(final Semigroup<E> s, final Validation<E, F<T, A>> v) {
     return isFail() ?
-        Validation.<E, A>fail(v.isFail() ?
+        Validation.fail(v.isFail() ?
             s.sum(v.fail(), fail()) :
             fail()) :
         v.isFail() ?
-            Validation.<E, A>fail(v.fail()) :
-            Validation.<E, A>success(v.success().f(success()));
+            Validation.fail(v.fail()) :
+            Validation.success(v.success().f(success()));
   }
 
   /**
@@ -722,7 +722,7 @@ public Iterator<T> iterator() {
 
     public Validation<List<E>, T> accumulate() {
         if (isFail()) {
-            return fail(List.<E>single(fail()));
+            return fail(List.single(fail()));
         } else {
             return success(success());
         }
@@ -730,7 +730,7 @@ public Validation<List<E>, T> accumulate() {
 
     public <B> Validation<List<E>, B> accumulate(F<T, B> f) {
         if (isFail()) {
-            return fail(List.<E>single(fail()));
+            return fail(List.single(fail()));
         } else {
             return success(f.f(success()));
         }
@@ -969,7 +969,7 @@ public <A> Validation<A, T> map(final F<E, A> f) {
      * @return A new validation value after binding.
      */
     public <A> Validation<A, T> bind(final F<E, Validation<A, T>> f) {
-      return v.isFail() ? f.f(v.fail()) : Validation.<A, T>success(v.success());
+      return v.isFail() ? f.f(v.fail()) : Validation.success(v.success());
     }
 
     /**
@@ -992,7 +992,7 @@ public <A> Validation<A, T> sequence(final Validation<A, T> v) {
      *         failing value, otherwise, returns a fail in <code>Some</code>.
      */
     public <A> Option<Validation<E, A>> filter(final F<E, Boolean> f) {
-      return v.toEither().left().<A>filter(f).map(Validation.<E, A>validation());
+      return v.toEither().left().<A>filter(f).map(Validation.validation());
     }
 
     /**
@@ -1083,8 +1083,8 @@ public Iterator<E> iterator() {
   @SuppressWarnings("unchecked")
   public Validation<NonEmptyList<E>, T> nel() {
     return isSuccess() ?
-        Validation.<NonEmptyList<E>, T>success(success()) :
-        Validation.<NonEmptyList<E>, T>fail(NonEmptyList.nel(fail()));
+        Validation.success(success()) :
+        Validation.fail(NonEmptyList.nel(fail()));
   }
 
   /**
@@ -1122,7 +1122,7 @@ public static <E, T> F<Validation<E, T>, Either<E, T>> either() {
    * @return A succeeding validation containing the given value.
    */
   public static <E, T> Validation<E, T> success(final T t) {
-    return validation(Either.<E, T>right(t));
+    return validation(Either.right(t));
   }
 
   /**
@@ -1132,7 +1132,7 @@ public static <E, T> Validation<E, T> success(final T t) {
    * @return A failing validation containing the given value.
    */
   public static <E, T> Validation<E, T> fail(final E e) {
-    return validation(Either.<E, T>left(e));
+    return validation(Either.left(e));
   }
 
   /**
@@ -1155,7 +1155,7 @@ public static <E, T> Validation<NonEmptyList<E>, T> failNEL(final E e) {
    * @return A validation based on a boolean condition.
    */
   public static <E, T> Validation<E, T> condition(final boolean c, final E e, final T t) {
-    return c ? Validation.<E, T>success(t) : Validation.<E, T>fail(e);
+    return c ? Validation.success(t) : Validation.fail(e);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Writer.java b/core/src/main/java/fj/data/Writer.java
index b384e259..b6b4579b 100644
--- a/core/src/main/java/fj/data/Writer.java
+++ b/core/src/main/java/fj/data/Writer.java
@@ -34,11 +34,11 @@ public Monoid<W> monoid() {
 	}
 
 	public static <W, A> Writer<W, A> unit(A a, W w, Monoid<W> m) {
-		return new Writer<W, A>(a, w, m);
+		return new Writer<>(a, w, m);
 	}
 
     public static <W, A> Writer<W, A> unit(A a, Monoid<W> m) {
-        return new Writer<W, A>(a, m.zero(), m);
+        return new Writer<>(a, m.zero(), m);
     }
 
     public Writer<W, A> tell(W w) {
diff --git a/core/src/main/java/fj/data/Zipper.java b/core/src/main/java/fj/data/Zipper.java
index f24ecf01..24414ed2 100644
--- a/core/src/main/java/fj/data/Zipper.java
+++ b/core/src/main/java/fj/data/Zipper.java
@@ -54,7 +54,7 @@ private Zipper(final Stream<A> left, final A focus, final Stream<A> right) {
    * @return a new Zipper with the given streams before and after the focus, and the given focused item.
    */
   public static <A> Zipper<A> zipper(final Stream<A> left, final A focus, final Stream<A> right) {
-    return new Zipper<A>(left, focus, right);
+    return new Zipper<>(left, focus, right);
   }
 
   /**
@@ -65,7 +65,7 @@ public static <A> Zipper<A> zipper(final Stream<A> left, final A focus, final St
    * @return a new Zipper created from the given triple.
    */
   public static <A> Zipper<A> zipper(final P3<Stream<A>, A, Stream<A>> p) {
-    return new Zipper<A>(p._1(), p._2(), p._3());
+    return new Zipper<>(p._1(), p._2(), p._3());
   }
 
   /**
@@ -103,7 +103,7 @@ public static <A> F<Zipper<A>, P3<Stream<A>, A, Stream<A>>> p_() {
    */
   public static <A> Ord<Zipper<A>> ord(final Ord<A> o) {
     final Ord<Stream<A>> so = Ord.streamOrd(o);
-    return Ord.p3Ord(so, o, so).contramap(Zipper.<A>p_());
+    return Ord.p3Ord(so, o, so).contramap(Zipper.p_());
   }
 
   /**
@@ -114,7 +114,7 @@ public static <A> Ord<Zipper<A>> ord(final Ord<A> o) {
    */
   public static <A> Equal<Zipper<A>> eq(final Equal<A> e) {
     final Equal<Stream<A>> se = Equal.streamEqual(e);
-    return Equal.p3Equal(se, e, se).contramap(Zipper.<A>p_());
+    return Equal.p3Equal(se, e, se).contramap(Zipper.p_());
   }
 
   /**
@@ -125,7 +125,7 @@ public static <A> Equal<Zipper<A>> eq(final Equal<A> e) {
    */
   public static <A> Show<Zipper<A>> show(final Show<A> s) {
     final Show<Stream<A>> ss = Show.streamShow(s);
-    return Show.p3Show(ss, s, ss).contramap(Zipper.<A>p_());
+    return Show.p3Show(ss, s, ss).contramap(Zipper.p_());
   }
 
   /**
@@ -148,7 +148,7 @@ public <B> Zipper<B> map(final F<A, B> f) {
   public <B> B foldRight(final F<A, F<B, B>> f, final B z) {
     return left.foldLeft(flip(f),
                          right.cons(focus).foldRight(compose(
-                             Function.<P1<B>, B, B>andThen().f(P1.<B>__1()), f), z));
+                             Function.<P1<B>, B, B>andThen().f(P1.__1()), f), z));
   }
 
   /**
@@ -158,7 +158,7 @@ public <B> B foldRight(final F<A, F<B, B>> f, final B z) {
    * @return a new zipper with a single element which is in focus.
    */
   public static <A> Zipper<A> single(final A a) {
-    return zipper(Stream.<A>nil(), a, Stream.<A>nil());
+    return zipper(Stream.nil(), a, Stream.nil());
   }
 
   /**
@@ -174,7 +174,7 @@ public static <A> Option<Zipper<A>> fromStream(final Stream<A> a) {
     if (a.isEmpty())
       return none();
     else
-      return some(zipper(Stream.<A>nil(), a.head(), a.tail()._1()));
+      return some(zipper(Stream.nil(), a.head(), a.tail()._1()));
   }
 
   /**
@@ -190,7 +190,7 @@ public static <A> Option<Zipper<A>> fromStreamEnd(final Stream<A> a) {
       return none();
     else {
       final Stream<A> xs = a.reverse();
-      return some(zipper(xs.tail()._1(), xs.head(), Stream.<A>nil()));
+      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
     }
   }
 
@@ -210,7 +210,7 @@ public A focus() {
    *         focus, otherwise None.
    */
   public Option<Zipper<A>> next() {
-    return right.isEmpty() ? Option.<Zipper<A>>none() : some(tryNext());
+    return right.isEmpty() ? Option.none() : some(tryNext());
   }
 
   /**
@@ -233,7 +233,7 @@ public Zipper<A> tryNext() {
    *         focus, otherwise None.
    */
   public Option<Zipper<A>> previous() {
-    return left.isEmpty() ? Option.<Zipper<A>>none() : some(tryPrevious());
+    return left.isEmpty() ? Option.none() : some(tryPrevious());
   }
 
   /**
@@ -297,7 +297,7 @@ public Zipper<A> insertRight(final A a) {
    */
   public Option<Zipper<A>> deleteLeft() {
     return left.isEmpty() && right.isEmpty()
-           ? Option.<Zipper<A>>none()
+           ? Option.none()
            : some(zipper(left.isEmpty() ? left : left.tail()._1(),
                          left.isEmpty() ? right.head() : left.head(),
                          left.isEmpty() ? right.tail()._1() : right));
@@ -313,7 +313,7 @@ public Option<Zipper<A>> deleteLeft() {
    */
   public Option<Zipper<A>> deleteRight() {
     return left.isEmpty() && right.isEmpty()
-           ? Option.<Zipper<A>>none()
+           ? Option.none()
            : some(zipper(right.isEmpty() ? left.tail()._1() : left,
                          right.isEmpty() ? left.head() : right.head(),
                          right.isEmpty() ? right : right.tail()._1()));
@@ -335,7 +335,7 @@ public Zipper<A> deleteOthers() {
    * @return the length of this zipper.
    */
   public int length() {
-    return foldRight(Function.<A, F<Integer, Integer>>constant(Integers.add.f(1)), 0);
+    return foldRight(Function.constant(Integers.add.f(1)), 0);
   }
 
   /**
@@ -365,9 +365,9 @@ public boolean atEnd() {
    */
   public Zipper<Zipper<A>> positions() {
     final Stream<Zipper<A>> left = Stream.unfold(
-            p -> p.previous().map(join(P.<Zipper<A>, Zipper<A>>p2())), this);
+            p -> p.previous().map(join(P.p2())), this);
     final Stream<Zipper<A>> right = Stream.unfold(
-            p -> p.next().map(join(P.<Zipper<A>, Zipper<A>>p2())), this);
+            p -> p.next().map(join(P.p2())), this);
 
     return zipper(left, this, right);
   }
@@ -407,10 +407,10 @@ public Option<Zipper<A>> move(final int n) {
       return none();
     else if (ll >= n)
       for (int i = ll - n; i > 0; i--)
-        p = p.bind(Zipper.<A>previous_());
+        p = p.bind(Zipper.previous_());
     else if (rl >= n)
       for (int i = rl - n; i > 0; i--)
-        p = p.bind(Zipper.<A>next_());
+        p = p.bind(Zipper.next_());
     return p;
   }
 
@@ -458,7 +458,7 @@ public Zipper<A> cycleNext() {
       return this;
     else if (right.isEmpty()) {
       final Stream<A> xs = left.reverse();
-      return zipper(Stream.<A>nil(), xs.head(), xs.tail()._1().snoc(P.p(focus)));
+      return zipper(Stream.nil(), xs.head(), xs.tail()._1().snoc(P.p(focus)));
     } else
       return tryNext();
   }
@@ -474,7 +474,7 @@ public Zipper<A> cyclePrevious() {
       return this;
     else if (left.isEmpty()) {
       final Stream<A> xs = right.reverse();
-      return zipper(xs.tail()._1().snoc(P.p(focus)), xs.head(), Stream.<A>nil());
+      return zipper(xs.tail()._1().snoc(P.p(focus)), xs.head(), Stream.nil());
     } else
       return tryPrevious();
   }
@@ -493,7 +493,7 @@ else if (left.isNotEmpty())
       return some(zipper(left.tail()._1(), left.head(), right));
     else {
       final Stream<A> xs = right.reverse();
-      return some(zipper(xs.tail()._1(), xs.head(), Stream.<A>nil()));
+      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
     }
   }
 
@@ -511,7 +511,7 @@ else if (right.isNotEmpty())
       return some(zipper(left, right.head(), right.tail()._1()));
     else {
       final Stream<A> xs = left.reverse();
-      return some(zipper(Stream.<A>nil(), xs.head(), xs.tail()._1()));
+      return some(zipper(Stream.nil(), xs.head(), xs.tail()._1()));
     }
   }
 
diff --git a/core/src/main/java/fj/data/fingertrees/Deep.java b/core/src/main/java/fj/data/fingertrees/Deep.java
index 17e775e6..ea906507 100644
--- a/core/src/main/java/fj/data/fingertrees/Deep.java
+++ b/core/src/main/java/fj/data/fingertrees/Deep.java
@@ -57,24 +57,24 @@ public Digit<V, A> suffix() {
   }
 
   @Override public <B> B foldRight(final F<A, F<B, B>> aff, final B z) {
-    return prefix.foldRight(aff, middle.foldRight(flip(Node.<V, A, B>foldRight_(aff)), suffix.foldRight(aff, z)));
+    return prefix.foldRight(aff, middle.foldRight(flip(Node.foldRight_(aff)), suffix.foldRight(aff, z)));
   }
 
   @Override public A reduceRight(final F<A, F<A, A>> aff) {
-    return prefix.foldRight(aff, middle.foldRight(flip(Node.<V, A, A>foldRight_(aff)), suffix.reduceRight(aff)));
+    return prefix.foldRight(aff, middle.foldRight(flip(Node.foldRight_(aff)), suffix.reduceRight(aff)));
   }
 
   @Override public <B> B foldLeft(final F<B, F<A, B>> bff, final B z) {
-    return suffix.foldLeft(bff, middle.foldLeft(Node.<V, A, B>foldLeft_(bff), prefix.foldLeft(bff, z)));
+    return suffix.foldLeft(bff, middle.foldLeft(Node.foldLeft_(bff), prefix.foldLeft(bff, z)));
   }
 
   @Override public A reduceLeft(final F<A, F<A, A>> aff) {
-    return suffix.foldLeft(aff, middle.foldLeft(Node.<V, A, A>foldLeft_(aff), prefix.reduceLeft(aff)));
+    return suffix.foldLeft(aff, middle.foldLeft(Node.foldLeft_(aff), prefix.reduceLeft(aff)));
   }
 
   @Override public <B> FingerTree<V, B> map(final F<A, B> abf, final Measured<V, B> m) {
-    return new Deep<V, B>(m, v, prefix.map(abf, m), middle.map(Node.<V, A, B>liftM(abf, m), m.nodeMeasured()),
-                          suffix.map(abf, m));
+    return new Deep<>(m, v, prefix.map(abf, m), middle.map(Node.liftM(abf, m), m.nodeMeasured()),
+        suffix.map(abf, m));
   }
 
   /**
@@ -281,9 +281,9 @@ private static <V, A> FingerTree<V, Node<V, A>> append1(final Measured<V, A> m,
                                                           final Node<V, A> a, final FingerTree<V, Node<V, A>> ys) {
     return xs.match(empty -> ys.cons(a), single -> ys.cons(a).cons(single.value()), deep1 -> ys.match(empty -> xs.snoc(a), single -> xs.snoc(a).snoc(single.value()), deep2 -> {
       final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-      return new Deep<V, Node<V, A>>(nm, m.sum(m.sum(deep1.v, nm.measure(a)), deep2.v), deep1.prefix,
-                                     addDigits1(nm, deep1.middle, deep1.suffix, a, deep2.prefix, deep2.middle),
-                                     deep2.suffix);
+      return new Deep<>(nm, m.sum(m.sum(deep1.v, nm.measure(a)), deep2.v), deep1.prefix,
+          addDigits1(nm, deep1.middle, deep1.suffix, a, deep2.prefix, deep2.middle),
+          deep2.suffix);
     }));
   }
 
@@ -336,11 +336,11 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits1(final Measur
   private static <V, A> FingerTree<V, Node<V, A>> append2(final Measured<V, A> m, final FingerTree<V, Node<V, A>> t1,
                                                           final Node<V, A> n1, final Node<V, A> n2,
                                                           final FingerTree<V, Node<V, A>> t2) {
-    return t1.match(empty -> t2.cons(n2).cons(n1), single -> t2.cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2), single -> deep.snoc(n1).snoc(n2).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(m.nodeMeasured(),
-                                   m.sum(m.sum(m.sum(deep.measure(), n1.measure()), n2.measure()),
-                                         deep2.measure()), deep.prefix,
-                                   addDigits2(m.nodeMeasured(), deep.middle, deep.suffix, n1, n2, deep2.prefix,
-                                              deep2.middle), deep2.suffix)));
+    return t1.match(empty -> t2.cons(n2).cons(n1), single -> t2.cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2), single -> deep.snoc(n1).snoc(n2).snoc(single.value()), deep2 -> new Deep<>(m.nodeMeasured(),
+        m.sum(m.sum(m.sum(deep.measure(), n1.measure()), n2.measure()),
+            deep2.measure()), deep.prefix,
+        addDigits2(m.nodeMeasured(), deep.middle, deep.suffix, n1, n2, deep2.prefix,
+            deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits2(final Measured<V, Node<V, A>> m,
@@ -395,10 +395,10 @@ private static <V, A> FingerTree<V, Node<V, A>> append3(final Measured<V, A> m,
                                                           final Node<V, A> n1, final Node<V, A> n2, final Node<V, A> n3,
                                                           final FingerTree<V, Node<V, A>> t2) {
     final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-    return t1.match(empty -> t2.cons(n3).cons(n2).cons(n1), single -> t2.cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2).snoc(n3), single -> deep.snoc(n1).snoc(n2).snoc(n3).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(nm, nm.monoid().sumLeft(
+    return t1.match(empty -> t2.cons(n3).cons(n2).cons(n1), single -> t2.cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> deep.snoc(n1).snoc(n2).snoc(n3), single -> deep.snoc(n1).snoc(n2).snoc(n3).snoc(single.value()), deep2 -> new Deep<>(nm, nm.monoid().sumLeft(
         list(deep.v, n1.measure(), n2.measure(), n3.measure(), deep2.v)), deep.prefix,
-                                   addDigits3(nm, deep.middle, deep.suffix, n1, n2, n3, deep2.prefix,
-                                              deep2.middle), deep2.suffix)));
+        addDigits3(nm, deep.middle, deep.suffix, n1, n2, n3, deep2.prefix,
+            deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits3(final Measured<V, Node<V, A>> m,
@@ -462,10 +462,10 @@ private static <V, A> FingerTree<V, Node<V, A>> append4(final Measured<V, A> m,
                                                           final Node<V, A> n4,
                                                           final FingerTree<V, Node<V, A>> t2) {
     final Measured<V, Node<V, A>> nm = m.nodeMeasured();
-    return t1.match(empty -> t2.cons(n4).cons(n3).cons(n2).cons(n1), single -> t2.cons(n4).cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4), single -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4).snoc(single.value()), deep2 -> new Deep<V, Node<V, A>>(nm, m.monoid().sumLeft(
+    return t1.match(empty -> t2.cons(n4).cons(n3).cons(n2).cons(n1), single -> t2.cons(n4).cons(n3).cons(n2).cons(n1).cons(single.value()), deep -> t2.match(empty -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4), single -> t1.snoc(n1).snoc(n2).snoc(n3).snoc(n4).snoc(single.value()), deep2 -> new Deep<>(nm, m.monoid().sumLeft(
         list(deep.v, n1.measure(), n2.measure(), n3.measure(), n4.measure(), deep2.v)), deep.prefix,
-                                   addDigits4(nm, deep.middle, deep.suffix, n1, n2, n3, n4, deep2.prefix,
-                                              deep2.middle), deep2.suffix)));
+        addDigits4(nm, deep.middle, deep.suffix, n1, n2, n3, n4, deep2.prefix,
+            deep2.middle), deep2.suffix)));
   }
 
   private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits4(final Measured<V, Node<V, A>> m,
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
index 2b51f7a7..415f08c2 100644
--- a/core/src/main/java/fj/data/fingertrees/Digit.java
+++ b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -88,10 +88,10 @@ public final A reduceLeft(final F<A, F<A, A>> f) {
    */
   public final <B> Digit<V, B> map(final F<A, B> f, final Measured<V, B> m) {
     return match(
-        one -> new One<V, B>(m, f.f(one.value())),
-        two -> new Two<V, B>(m, two.values().map(f)),
-        three -> new Three<V, B>(m, three.values().map(f)),
-        four -> new Four<V, B>(m, four.values().map(f))
+        one -> new One<>(m, f.f(one.value())),
+        two -> new Two<>(m, two.values().map(f)),
+        three -> new Three<>(m, three.values().map(f)),
+        four -> new Four<>(m, four.values().map(f))
     );
   }
 
@@ -132,27 +132,27 @@ public final FingerTree<V, A> toTree() {
         final MakeTree<V, A> mk = mkTree(m);
         return match(
             one -> mk.single(one.value()),
-            two -> mk.deep(mk.one(two.values()._1()), new Empty<V, Node<V, A>>(m.nodeMeasured()), mk.one(two.values()._2())),
-            three -> mk.deep(mk.two(three.values()._1(), three.values()._2()), new Empty<V, Node<V, A>>(m.nodeMeasured()), mk.one(three.values()._3())),
-            four -> mk.deep(mk.two(four.values()._1(), four.values()._2()), new Empty<V, Node<V, A>>(m.nodeMeasured()), mk.two(four.values()._3(), four.values()._4()))
+            two -> mk.deep(mk.one(two.values()._1()), new Empty<>(m.nodeMeasured()), mk.one(two.values()._2())),
+            three -> mk.deep(mk.two(three.values()._1(), three.values()._2()), new Empty<>(m.nodeMeasured()), mk.one(three.values()._3())),
+            four -> mk.deep(mk.two(four.values()._1(), four.values()._2()), new Empty<>(m.nodeMeasured()), mk.two(four.values()._3(), four.values()._4()))
         );
     }
 
   Option<Digit<V, A>> tail() {
     return match(
-      one -> Option.<Digit<V, A>> none(),
-      two -> Option.<Digit<V, A>> some(mkTree(m).one(two.values()._2())),
-      three -> Option.<Digit<V, A>> some(mkTree(m).two(three.values()._2(), three.values()._3())),
-      four -> Option.<Digit<V, A>> some(mkTree(m).three(four.values()._2(), four.values()._3(), four.values()._4()))
+      one -> Option.none(),
+      two -> Option.some(mkTree(m).one(two.values()._2())),
+      three -> Option.some(mkTree(m).two(three.values()._2(), three.values()._3())),
+      four -> Option.some(mkTree(m).three(four.values()._2(), four.values()._3(), four.values()._4()))
     );
   }
 
   Option<Digit<V, A>> init() {
     return match(
-      one -> Option.<Digit<V, A>> none(),
-      two -> Option.<Digit<V, A>> some(mkTree(m).one(two.values()._1())),
-      three -> Option.<Digit<V, A>> some(mkTree(m).two(three.values()._1(), three.values()._2())),
-      four -> Option.<Digit<V, A>> some(mkTree(m).three(four.values()._1(), four.values()._2(), four.values()._3()))
+      one -> Option.none(),
+      two -> Option.some(mkTree(m).one(two.values()._1())),
+      three -> Option.some(mkTree(m).two(three.values()._1(), three.values()._2())),
+      four -> Option.some(mkTree(m).three(four.values()._1(), four.values()._2(), four.values()._3()))
     );
   }
 
diff --git a/core/src/main/java/fj/data/fingertrees/Empty.java b/core/src/main/java/fj/data/fingertrees/Empty.java
index 9f2b9bd2..95065aef 100644
--- a/core/src/main/java/fj/data/fingertrees/Empty.java
+++ b/core/src/main/java/fj/data/fingertrees/Empty.java
@@ -15,7 +15,7 @@ public final class Empty<V, A> extends FingerTree<V, A> {
   }
 
   @Override public FingerTree<V, A> cons(final A a) {
-    return new Single<V, A>(measured(), a);
+    return new Single<>(measured(), a);
   }
 
   @Override public FingerTree<V, A> snoc(final A a) {
@@ -58,7 +58,7 @@ public A reduceRight(final F<A, F<A, A>> aff) {
   }
 
   @Override public <B> FingerTree<V, B> map(final F<A, B> abf, final Measured<V, B> m) {
-    return new Empty<V, B>(m);
+    return new Empty<>(m);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index 1078374b..060e976f 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -77,7 +77,7 @@ public <B> B foldLeft(final F2<B, A, B> f, final B z) {
   public abstract <B> FingerTree<V, B> map(final F<A, B> f, final Measured<V, B> m);
 
     public <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
-        FingerTree<V, A> tree = new Empty<V, A>(m);
+        FingerTree<V, A> tree = new Empty<>(m);
         return foldLeft((acc, a) -> f.f(a) ? acc.snoc(a) : acc, tree);
     }
 
@@ -134,7 +134,7 @@ public static <V, A> Measured<V, A> measured(final Monoid<V> monoid, final F<A,
    * @return A builder of trees and tree components that annotates them using the given Measured instance.
    */
   public static <V, A> MakeTree<V, A> mkTree(final Measured<V, A> m) {
-    return new MakeTree<V, A>(m);
+    return new MakeTree<>(m);
   }
 
   /**
@@ -161,7 +161,7 @@ public static <V, A> MakeTree<V, A> mkTree(final Measured<V, A> m) {
   public abstract A head();
 
   public Option<A> headOption() {
-      return isEmpty() ? Option.<A>none() : Option.some(head());
+      return isEmpty() ? Option.none() : Option.some(head());
   }
 
   /**
diff --git a/core/src/main/java/fj/data/fingertrees/MakeTree.java b/core/src/main/java/fj/data/fingertrees/MakeTree.java
index b435d955..b2a3da84 100644
--- a/core/src/main/java/fj/data/fingertrees/MakeTree.java
+++ b/core/src/main/java/fj/data/fingertrees/MakeTree.java
@@ -14,7 +14,7 @@ public final class MakeTree<V, A> {
 
   MakeTree(final Measured<V, A> m) {
     this.m = m;
-    this.empty = new Empty<V, A>(m);
+    this.empty = new Empty<>(m);
   }
 
   // Tree constructors
@@ -35,7 +35,7 @@ public FingerTree<V, A> empty() {
    * @return A tree with the given value as the single element.
    */
   public FingerTree<V, A> single(final A a) {
-    return new Single<V, A>(m, a);
+    return new Single<>(m, a);
   }
 
   /**
@@ -63,7 +63,7 @@ public FingerTree<V, A> deep(final Digit<V, A> prefix, final FingerTree<V, Node<
    */
   public FingerTree<V, A> deep(final V v, final Digit<V, A> prefix, final FingerTree<V, Node<V, A>> middle,
                                final Digit<V, A> suffix) {
-    return new Deep<V, A>(m, v, prefix, middle, suffix);
+    return new Deep<>(m, v, prefix, middle, suffix);
   }
 
   // Digit constructors
@@ -75,7 +75,7 @@ public FingerTree<V, A> deep(final V v, final Digit<V, A> prefix, final FingerTr
    * @return A digit of the given element.
    */
   public One<V, A> one(final A a) {
-    return new One<V, A>(m, a);
+    return new One<>(m, a);
   }
 
   /**
@@ -86,7 +86,7 @@ public One<V, A> one(final A a) {
    * @return A digit of the given elements.
    */
   public Two<V, A> two(final A a, final A b) {
-    return new Two<V, A>(m, v(a, b));
+    return new Two<>(m, v(a, b));
   }
 
   /**
@@ -98,7 +98,7 @@ public Two<V, A> two(final A a, final A b) {
    * @return A digit of the given elements.
    */
   public Three<V, A> three(final A a, final A b, final A c) {
-    return new Three<V, A>(m, v(a, b, c));
+    return new Three<>(m, v(a, b, c));
   }
 
   /**
@@ -111,7 +111,7 @@ public Three<V, A> three(final A a, final A b, final A c) {
    * @return A digit of the given elements.
    */
   public Four<V, A> four(final A a, final A b, final A c, final A d) {
-    return new Four<V, A>(m, v(a, b, c, d));
+    return new Four<>(m, v(a, b, c, d));
   }
 
   // Node constructors
@@ -124,7 +124,7 @@ public Four<V, A> four(final A a, final A b, final A c, final A d) {
    * @return A new binary tree node.
    */
   public Node2<V, A> node2(final A a, final A b) {
-    return new Node2<V, A>(m, v(a, b));
+    return new Node2<>(m, v(a, b));
   }
 
   /**
@@ -136,7 +136,7 @@ public Node2<V, A> node2(final A a, final A b) {
    * @return A new trinary tree node.
    */
   public Node3<V, A> node3(final A a, final A b, final A c) {
-    return new Node3<V, A>(m, v(a, b, c));
+    return new Node3<>(m, v(a, b, c));
   }
 
   /**
@@ -146,7 +146,7 @@ public Node3<V, A> node3(final A a, final A b, final A c) {
    * @return A new binary tree node.
    */
   public Node2<V, A> node2(final V2<A> v) {
-    return new Node2<V, A>(m, v);
+    return new Node2<>(m, v);
   }
 
   /**
@@ -156,7 +156,7 @@ public Node2<V, A> node2(final V2<A> v) {
    * @return A new trinary tree node.
    */
   public Node3<V, A> node3(final V3<A> v) {
-    return new Node3<V, A>(m, v);
+    return new Node3<>(m, v);
   }
 
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Measured.java b/core/src/main/java/fj/data/fingertrees/Measured.java
index d33b5726..28c94abe 100644
--- a/core/src/main/java/fj/data/fingertrees/Measured.java
+++ b/core/src/main/java/fj/data/fingertrees/Measured.java
@@ -17,7 +17,7 @@ private Measured(final Monoid<V> m, final F<A, V> measure) {
   }
 
   public static <V, A> Measured<V, A> measured(final Monoid<V> m, final F<A, V> measure) {
-    return new Measured<V, A>(m, measure);
+    return new Measured<>(m, measure);
   }
 
   /**
@@ -74,7 +74,7 @@ public V zero() {
    * @return A measured instance for nodes.
    */
   public Measured<V, Node<V, A>> nodeMeasured() {
-    return new Measured<V, Node<V, A>>(m, Node::measure);
+    return new Measured<>(m, Node::measure);
   }
 
   /**
@@ -83,7 +83,7 @@ public Measured<V, Node<V, A>> nodeMeasured() {
    * @return A measured instance for digits.
    */
   public Measured<V, Digit<V, A>> digitMeasured() {
-    return new Measured<V, Digit<V, A>>(m, Digit::measure);
+    return new Measured<>(m, Digit::measure);
   }
 
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node.java b/core/src/main/java/fj/data/fingertrees/Node.java
index d107c8d4..674195d7 100644
--- a/core/src/main/java/fj/data/fingertrees/Node.java
+++ b/core/src/main/java/fj/data/fingertrees/Node.java
@@ -28,8 +28,8 @@ public static <V, A, B> F<B, F<Node<V, A>, B>> foldRight_(final F<A, F<B, B>> af
 
   public final <B> Node<V, B> map(final F<A, B> f, final Measured<V, B> m) {
     return match(
-        node2 -> new Node2<V, B>(m, node2.toVector().map(f)),
-        node3 -> new Node3<V, B>(m, node3.toVector().map(f))
+        node2 -> new Node2<>(m, node2.toVector().map(f)),
+        node3 -> new Node3<>(m, node3.toVector().map(f))
     );
   }
 
diff --git a/core/src/main/java/fj/data/fingertrees/Node2.java b/core/src/main/java/fj/data/fingertrees/Node2.java
index 5fc979be..5af121c2 100644
--- a/core/src/main/java/fj/data/fingertrees/Node2.java
+++ b/core/src/main/java/fj/data/fingertrees/Node2.java
@@ -31,7 +31,7 @@ public final class Node2<V, A> extends Node<V, A> {
   }
 
   public Digit<V, A> toDigit() {
-    return new Two<V, A>(measured(), as);
+    return new Two<>(measured(), as);
   }
 
   P3<Option<Digit<V, A>>, A, Option<Digit<V, A>>> split1(final F<V, Boolean> predicate, final V acc) {
diff --git a/core/src/main/java/fj/data/fingertrees/Node3.java b/core/src/main/java/fj/data/fingertrees/Node3.java
index 233fcda7..5eb9bf58 100644
--- a/core/src/main/java/fj/data/fingertrees/Node3.java
+++ b/core/src/main/java/fj/data/fingertrees/Node3.java
@@ -40,7 +40,7 @@ public int length() {
     }
 
     public Digit<V, A> toDigit() {
-    return new Three<V, A>(measured(), as);
+    return new Three<>(measured(), as);
   }
 
   P3<Option<Digit<V, A>>, A, Option<Digit<V, A>>> split1(final F<V, Boolean> predicate, final V acc) {
diff --git a/core/src/main/java/fj/data/fingertrees/Single.java b/core/src/main/java/fj/data/fingertrees/Single.java
index 1bbe7884..d322dcaa 100644
--- a/core/src/main/java/fj/data/fingertrees/Single.java
+++ b/core/src/main/java/fj/data/fingertrees/Single.java
@@ -37,7 +37,7 @@ public final class Single<V, A> extends FingerTree<V, A> {
   }
 
   @Override public <B> FingerTree<V, B> map(final F<A, B> abf, final Measured<V, B> m) {
-    return new Single<V, B>(m, abf.f(a));
+    return new Single<>(m, abf.f(a));
   }
 
   /**
@@ -59,12 +59,12 @@ public V measure() {
 
   @Override public FingerTree<V, A> cons(final A b) {
     final MakeTree<V, A> mk = mkTree(measured());
-    return mk.deep(mk.one(b), new Empty<V, Node<V, A>>(measured().nodeMeasured()), mk.one(a));
+    return mk.deep(mk.one(b), new Empty<>(measured().nodeMeasured()), mk.one(a));
   }
 
   @Override public FingerTree<V, A> snoc(final A b) {
     final MakeTree<V, A> mk = mkTree(measured());
-    return mk.deep(mk.one(a), new Empty<V, Node<V, A>>(measured().nodeMeasured()), mk.one(b));
+    return mk.deep(mk.one(a), new Empty<>(measured().nodeMeasured()), mk.one(b));
   }
 
   @Override public A head() { return a; }
diff --git a/core/src/main/java/fj/data/hlist/HList.java b/core/src/main/java/fj/data/hlist/HList.java
index b02d9504..639c9e64 100644
--- a/core/src/main/java/fj/data/hlist/HList.java
+++ b/core/src/main/java/fj/data/hlist/HList.java
@@ -47,7 +47,7 @@ public static HNil nil() {
    * @return a heterogeneous list consisting of an element and another list.
    */
   public static <E, L extends HList<L>> HCons<E, L> cons(final E e, final L l) {
-    return new HCons<E, L>(e, l);
+    return new HCons<>(e, l);
   }
 
   /**
@@ -91,7 +91,7 @@ public C append(final A a, final B b) {
      * @return a method for concatenating lists to the empty list.
      */
     public static <L extends HList<L>> HAppend<HNil, L, L> append() {
-      return new HAppend<HNil, L, L>((hNil, l) -> l);
+      return new HAppend<>((hNil, l) -> l);
     }
 
     /**
@@ -102,7 +102,7 @@ public static <L extends HList<L>> HAppend<HNil, L, L> append() {
      */
     public static <X, A extends HList<A>, B, C extends HList<C>, H extends HAppend<A, B, C>>
     HAppend<HCons<X, A>, B, HCons<X, C>> append(final H h) {
-      return new HAppend<HCons<X, A>, B, HCons<X, C>>((c, l) -> cons(c.head(), h.append(c.tail(), l)));
+      return new HAppend<>((c, l) -> cons(c.head(), h.append(c.tail(), l)));
     }
   }
 
@@ -212,7 +212,7 @@ private HFoldr(final F3<G, V, L, R> foldRight) {
      * @return a fold instance for the empty list.
      */
     public static <G, V> HFoldr<G, V, HNil, V> hFoldr() {
-      return new HFoldr<G, V, HNil, V>((f, v, hNil) -> v);
+      return new HFoldr<>((f, v, hNil) -> v);
     }
 
     /**
@@ -234,7 +234,7 @@ public static <G, V> HFoldr<G, V, HNil, V> hFoldr() {
         H extends HFoldr<G, V, L, R>,
         PP extends Apply<G, P2<E, R>, RR>>
     HFoldr<G, V, HCons<E, L>, RR> hFoldr(final PP p, final H h) {
-      return new HFoldr<G, V, HCons<E, L>, RR>((f, v, c) -> p.apply(f, P.p(c.head(), h.foldRight(f, v, c.tail()))));
+      return new HFoldr<>((f, v, c) -> p.apply(f, P.p(c.head(), h.foldRight(f, v, c.tail()))));
     }
 
     /**
diff --git a/core/src/main/java/fj/data/optic/Fold.java b/core/src/main/java/fj/data/optic/Fold.java
index 21aca09f..af6b5739 100644
--- a/core/src/main/java/fj/data/optic/Fold.java
+++ b/core/src/main/java/fj/data/optic/Fold.java
@@ -76,7 +76,7 @@ public final <B> Fold<S, B> composeFold(final Fold<A, B> other) {
     return new Fold<S, B>() {
       @Override
       public <C> F<S, C> foldMap(final Monoid<C> m, final F<B, C> f) {
-        return Fold.this.<C> foldMap(m, other.<C> foldMap(m, f));
+        return Fold.this.foldMap(m, other.<C> foldMap(m, f));
       }
     };
   }
diff --git a/core/src/main/java/fj/data/optic/Optional.java b/core/src/main/java/fj/data/optic/Optional.java
index 200a952d..b2106cae 100644
--- a/core/src/main/java/fj/data/optic/Optional.java
+++ b/core/src/main/java/fj/data/optic/Optional.java
@@ -180,7 +180,7 @@ public static final <S, A> Optional<S, A> optional(final F<S, Option<A>> getOpti
 
       @Override
       public Either<S, A> getOrModify(final S s) {
-        return getOption.f(s).option(Either.left(s), Either.<S, A> right_());
+        return getOption.f(s).option(Either.left(s), Either.right_());
       }
 
       @Override
@@ -213,7 +213,7 @@ public <L> F<S, Either<L, S>> modifyEitherF(final F<A, Either<L, A>> f) {
       public F<S, IO<S>> modifyIOF(final F<A, IO<A>> f) {
         return s -> getOption.f(s).option(
             IOFunctions.unit(s),
-            a -> IOFunctions.<A, S> map(f.f(a), b -> set.f(b).f(s))
+            a -> IOFunctions.map(f.f(a), b -> set.f(b).f(s))
             );
       }
 
diff --git a/core/src/main/java/fj/data/optic/POptional.java b/core/src/main/java/fj/data/optic/POptional.java
index 5c0bdd8c..73cc6fe9 100644
--- a/core/src/main/java/fj/data/optic/POptional.java
+++ b/core/src/main/java/fj/data/optic/POptional.java
@@ -403,7 +403,7 @@ public <L> F<S, Either<L, T>> modifyEitherF(final F<A, Either<L, B>> f) {
       public F<S, IO<T>> modifyIOF(final F<A, IO<B>> f) {
         return s -> getOrModify.f(s).either(
             IOFunctions::unit,
-            t -> IOFunctions.<B, T> map(f.f(t), b -> set.f(b).f(s))
+            t -> IOFunctions.map(f.f(t), b -> set.f(b).f(s))
             );
       }
 
diff --git a/core/src/main/java/fj/data/optic/Prism.java b/core/src/main/java/fj/data/optic/Prism.java
index 42decaaf..c2160b1f 100644
--- a/core/src/main/java/fj/data/optic/Prism.java
+++ b/core/src/main/java/fj/data/optic/Prism.java
@@ -95,7 +95,7 @@ public static <S, A> Prism<S, A> prism(final F<S, Option<A>> getOption, final F<
 
       @Override
       public Either<S, A> getOrModify(final S s) {
-        return getOption.f(s).option(Either.left(s), Either.<S, A> right_());
+        return getOption.f(s).option(Either.left(s), Either.right_());
       }
 
       @Override
diff --git a/core/src/main/java/fj/data/vector/V2.java b/core/src/main/java/fj/data/vector/V2.java
index 700a8409..fdab115c 100644
--- a/core/src/main/java/fj/data/vector/V2.java
+++ b/core/src/main/java/fj/data/vector/V2.java
@@ -30,7 +30,7 @@ private V2(final P2<A, A> inner) {
    * @return A new vector-2.
    */
   public static <A> V2<A> p(final P2<A, A> p) {
-    return new V2<A>(p);
+    return new V2<>(p);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V3.java b/core/src/main/java/fj/data/vector/V3.java
index ceb492bc..9b25258f 100644
--- a/core/src/main/java/fj/data/vector/V3.java
+++ b/core/src/main/java/fj/data/vector/V3.java
@@ -30,7 +30,7 @@ private V3(final P1<A> head, final V2<A> tail) {
    * @return A new vector-3.
    */
   public static <A> V3<A> p(final P3<A, A, A> p) {
-    return new V3<A>(
+    return new V3<>(
         P.lazy(p::_1),
         V2.p(P.lazy(p::_2, p::_3))
     );
@@ -44,7 +44,7 @@ public static <A> V3<A> p(final P3<A, A, A> p) {
    * @return The new vector.
    */
   public static <A> V3<A> cons(final P1<A> head, final V2<A> tail) {
-    return new V3<A>(head, tail);
+    return new V3<>(head, tail);
   }
 
   /**
@@ -131,7 +131,7 @@ public Array<A> toArray() {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V3<B> apply(final V3<F<A, B>> vf) {
-    return new V3<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V3<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
@@ -202,7 +202,7 @@ public Stream<A> toStream() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V3<B> map(final F<A, B> f) {
-    return new V3<B>(head().map(f), tail().map(f));
+    return new V3<>(head().map(f), tail().map(f));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V4.java b/core/src/main/java/fj/data/vector/V4.java
index 8e142023..1f39346b 100644
--- a/core/src/main/java/fj/data/vector/V4.java
+++ b/core/src/main/java/fj/data/vector/V4.java
@@ -30,20 +30,20 @@ private V4(final P1<A> head, final V3<A> tail) {
    * @return A new vector-4.
    */
   public static <A> V4<A> p(final P4<A, A, A, A> p) {
-    return new V4<A>(P.lazy(p::_1),
-    V3.p(new P3<A, A, A>() {
-      public A _1() {
-        return p._2();
-      }
-
-      public A _2() {
-        return p._3();
-      }
-
-      public A _3() {
-        return p._4();
-      }
-    }));
+    return new V4<>(P.lazy(p::_1),
+        V3.p(new P3<A, A, A>() {
+          public A _1() {
+            return p._2();
+          }
+
+          public A _2() {
+            return p._3();
+          }
+
+          public A _3() {
+            return p._4();
+          }
+        }));
   }
 
   /**
@@ -54,7 +54,7 @@ public A _3() {
    * @return The new vector.
    */
   public static <A> V4<A> cons(final P1<A> head, final V3<A> tail) {
-    return new V4<A>(head, tail);
+    return new V4<>(head, tail);
   }
 
   /**
@@ -180,7 +180,7 @@ public Array<A> toArray() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V4<B> map(final F<A, B> f) {
-    return new V4<B>(head.map(f), tail.map(f));
+    return new V4<>(head.map(f), tail.map(f));
   }
 
   /**
@@ -190,7 +190,7 @@ public <B> V4<B> map(final F<A, B> f) {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V4<B> apply(final V4<F<A, B>> vf) {
-    return new V4<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V4<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V5.java b/core/src/main/java/fj/data/vector/V5.java
index d386cb32..0119dcf9 100644
--- a/core/src/main/java/fj/data/vector/V5.java
+++ b/core/src/main/java/fj/data/vector/V5.java
@@ -30,24 +30,24 @@ private V5(final P1<A> head, final V4<A> tail) {
    * @return A new vector-5.
    */
   public static <A> V5<A> p(final P5<A, A, A, A, A> p) {
-    return new V5<A>(P.lazy(p::_1),
-    V4.p(new P4<A, A, A, A>() {
-      public A _1() {
-        return p._2();
-      }
-
-      public A _2() {
-        return p._3();
-      }
-
-      public A _3() {
-        return p._4();
-      }
-
-      public A _4() {
-        return p._5();
-      }
-    }));
+    return new V5<>(P.lazy(p::_1),
+        V4.p(new P4<A, A, A, A>() {
+          public A _1() {
+            return p._2();
+          }
+
+          public A _2() {
+            return p._3();
+          }
+
+          public A _3() {
+            return p._4();
+          }
+
+          public A _4() {
+            return p._5();
+          }
+        }));
   }
 
   /**
@@ -58,7 +58,7 @@ public A _4() {
    * @return The new vector.
    */
   public static <A> V5<A> cons(final P1<A> head, final V4<A> tail) {
-    return new V5<A>(head, tail);
+    return new V5<>(head, tail);
   }
 
   /**
@@ -197,7 +197,7 @@ public Array<A> toArray() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V5<B> map(final F<A, B> f) {
-    return new V5<B>(head.map(f), tail.map(f));
+    return new V5<>(head.map(f), tail.map(f));
   }
 
   /**
@@ -207,7 +207,7 @@ public <B> V5<B> map(final F<A, B> f) {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V5<B> apply(final V5<F<A, B>> vf) {
-    return new V5<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V5<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V6.java b/core/src/main/java/fj/data/vector/V6.java
index 107c01a5..47a0c4e7 100644
--- a/core/src/main/java/fj/data/vector/V6.java
+++ b/core/src/main/java/fj/data/vector/V6.java
@@ -30,28 +30,28 @@ private V6(final P1<A> head, final V5<A> tail) {
    * @return A new vector-6.
    */
   public static <A> V6<A> p(final P6<A, A, A, A, A, A> p) {
-    return new V6<A>(P.lazy(p::_1),
-    V5.p(new P5<A, A, A, A, A>() {
-      public A _1() {
-        return p._2();
-      }
-
-      public A _2() {
-        return p._3();
-      }
-
-      public A _3() {
-        return p._4();
-      }
-
-      public A _4() {
-        return p._5();
-      }
-
-      public A _5() {
-        return p._6();
-      }
-    }));
+    return new V6<>(P.lazy(p::_1),
+        V5.p(new P5<A, A, A, A, A>() {
+          public A _1() {
+            return p._2();
+          }
+
+          public A _2() {
+            return p._3();
+          }
+
+          public A _3() {
+            return p._4();
+          }
+
+          public A _4() {
+            return p._5();
+          }
+
+          public A _5() {
+            return p._6();
+          }
+        }));
   }
 
   /**
@@ -62,7 +62,7 @@ public A _5() {
    * @return The new vector.
    */
   public static <A> V6<A> cons(final P1<A> head, final V5<A> tail) {
-    return new V6<A>(head, tail);
+    return new V6<>(head, tail);
   }
 
   /**
@@ -214,7 +214,7 @@ public Array<A> toArray() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V6<B> map(final F<A, B> f) {
-    return new V6<B>(head.map(f), tail.map(f));
+    return new V6<>(head.map(f), tail.map(f));
   }
 
   /**
@@ -224,7 +224,7 @@ public <B> V6<B> map(final F<A, B> f) {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V6<B> apply(final V6<F<A, B>> vf) {
-    return new V6<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V6<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V7.java b/core/src/main/java/fj/data/vector/V7.java
index 52699481..c0dfa4b6 100644
--- a/core/src/main/java/fj/data/vector/V7.java
+++ b/core/src/main/java/fj/data/vector/V7.java
@@ -30,32 +30,32 @@ private V7(final P1<A> head, final V6<A> tail) {
    * @return A new vector-7.
    */
   public static <A> V7<A> p(final P7<A, A, A, A, A, A, A> p) {
-    return new V7<A>(P.lazy(p::_1),
-    V6.p(new P6<A, A, A, A, A, A>() {
-      public A _1() {
-        return p._2();
-      }
-
-      public A _2() {
-        return p._3();
-      }
-
-      public A _3() {
-        return p._4();
-      }
-
-      public A _4() {
-        return p._5();
-      }
-
-      public A _5() {
-        return p._6();
-      }
-
-      public A _6() {
-        return p._7();
-      }
-    }));
+    return new V7<>(P.lazy(p::_1),
+        V6.p(new P6<A, A, A, A, A, A>() {
+          public A _1() {
+            return p._2();
+          }
+
+          public A _2() {
+            return p._3();
+          }
+
+          public A _3() {
+            return p._4();
+          }
+
+          public A _4() {
+            return p._5();
+          }
+
+          public A _5() {
+            return p._6();
+          }
+
+          public A _6() {
+            return p._7();
+          }
+        }));
   }
 
   /**
@@ -66,7 +66,7 @@ public A _6() {
    * @return The new vector.
    */
   public static <A> V7<A> cons(final P1<A> head, final V6<A> tail) {
-    return new V7<A>(head, tail);
+    return new V7<>(head, tail);
   }
 
   /**
@@ -231,7 +231,7 @@ public Array<A> toArray() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V7<B> map(final F<A, B> f) {
-    return new V7<B>(head.map(f), tail.map(f));
+    return new V7<>(head.map(f), tail.map(f));
   }
 
   /**
@@ -241,7 +241,7 @@ public <B> V7<B> map(final F<A, B> f) {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V7<B> apply(final V7<F<A, B>> vf) {
-    return new V7<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V7<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/vector/V8.java b/core/src/main/java/fj/data/vector/V8.java
index 8ad96cdd..f01dc2fe 100644
--- a/core/src/main/java/fj/data/vector/V8.java
+++ b/core/src/main/java/fj/data/vector/V8.java
@@ -30,36 +30,36 @@ private V8(final P1<A> head, final V7<A> tail) {
    * @return A new vector-8.
    */
   public static <A> V8<A> p(final P8<A, A, A, A, A, A, A, A> p) {
-    return new V8<A>(P.lazy(p::_1),
-    V7.p(new P7<A, A, A, A, A, A, A>() {
-      public A _1() {
-        return p._2();
-      }
+    return new V8<>(P.lazy(p::_1),
+        V7.p(new P7<A, A, A, A, A, A, A>() {
+          public A _1() {
+            return p._2();
+          }
 
-      public A _2() {
-        return p._3();
-      }
+          public A _2() {
+            return p._3();
+          }
 
-      public A _3() {
-        return p._4();
-      }
+          public A _3() {
+            return p._4();
+          }
 
-      public A _4() {
-        return p._5();
-      }
+          public A _4() {
+            return p._5();
+          }
 
-      public A _5() {
-        return p._6();
-      }
+          public A _5() {
+            return p._6();
+          }
 
-      public A _6() {
-        return p._7();
-      }
+          public A _6() {
+            return p._7();
+          }
 
-      public A _7() {
-        return p._8();
-      }
-    }));
+          public A _7() {
+            return p._8();
+          }
+        }));
   }
 
   /**
@@ -70,7 +70,7 @@ public A _7() {
    * @return The new vector.
    */
   public static <A> V8<A> cons(final P1<A> head, final V7<A> tail) {
-    return new V8<A>(head, tail);
+    return new V8<>(head, tail);
   }
 
   /**
@@ -248,7 +248,7 @@ public Array<A> toArray() {
    * @return A new vector after the given function has been applied to each element.
    */
   public <B> V8<B> map(final F<A, B> f) {
-    return new V8<B>(head.map(f), tail.map(f));
+    return new V8<>(head.map(f), tail.map(f));
   }
 
   /**
@@ -258,7 +258,7 @@ public <B> V8<B> map(final F<A, B> f) {
    * @return A new vector after zipping the given vector of functions over this vector.
    */
   public <B> V8<B> apply(final V8<F<A, B>> vf) {
-    return new V8<B>(head.<B>apply(vf.head()), tail.apply(vf.tail()));
+    return new V8<>(head.apply(vf.head()), tail.apply(vf.tail()));
   }
 
   /**
diff --git a/core/src/main/java/fj/function/Visitor.java b/core/src/main/java/fj/function/Visitor.java
index 0f8c3846..bdca3b5e 100644
--- a/core/src/main/java/fj/function/Visitor.java
+++ b/core/src/main/java/fj/function/Visitor.java
@@ -42,7 +42,7 @@ public static <X> X findFirst(final List<Option<X>> values, final F0<X> def) {
    * @return The first non-<code>null</code> value in the given list of optional values. If none is found return the given default value.
    */
   public static <X> X nullablefindFirst(final List<X> values, final F0<X> def) {
-    return findFirst(values.map(Option.<X>fromNull()), def);
+    return findFirst(values.map(Option.fromNull()), def);
   }
 
   /**
@@ -56,7 +56,7 @@ public static <X> X nullablefindFirst(final List<X> values, final F0<X> def) {
    * given default.
    */
   public static <A, B> B visitor(final List<F<A, Option<B>>> visitors, final F0<B> def, final A value) {
-    return findFirst(visitors.map(Function.<A, Option<B>>apply(value)), def);
+    return findFirst(visitors.map(Function.apply(value)), def);
   }
 
   /**
@@ -70,7 +70,7 @@ public static <A, B> B visitor(final List<F<A, Option<B>>> visitors, final F0<B>
    * given default.
    */
   public static <A, B> B nullableVisitor(final List<F<A, B>> visitors, final F0<B> def, final A value) {
-    return visitor(visitors.map(k -> compose(Option.<B>fromNull(), k)), def, value);
+    return visitor(visitors.map(k -> compose(Option.fromNull(), k)), def, value);
   }
 
   /**
diff --git a/core/src/main/java/fj/parser/Parser.java b/core/src/main/java/fj/parser/Parser.java
index 605125f0..3ea6dd15 100644
--- a/core/src/main/java/fj/parser/Parser.java
+++ b/core/src/main/java/fj/parser/Parser.java
@@ -210,7 +210,7 @@ public <B> Parser<I, B, E> sequence(final Parser<I, B, E> p) {
    * @return A new parser after function application.
    */
   public <B> Parser<I, B, E> apply(final Parser<I, F<A, B>, E> p) {
-    return p.bind((F<F<A, B>, Parser<I, B, E>>) this::map);
+    return p.bind(this::map);
   }
 
   /**
@@ -265,8 +265,8 @@ public Parser<I, A, E> or(final Parser<I, A, E> alt, final Semigroup<E> s) {
    */
   public Parser<I, Unit, E> not(final F0<E> e) {
     return parser(i -> parse(i).isFail() ?
-        Validation.<E, Result<I, Unit>>success(result(i, unit())) :
-        Validation.<E, Result<I, Unit>>fail(e.f()));
+        Validation.success(result(i, unit())) :
+        Validation.fail(e.f()));
   }
 
   /**
@@ -285,7 +285,7 @@ public Parser<I, Unit, E> not(final E e) {
    * @return A parser that repeats application of this parser zero or many times.
    */
   public Parser<I, Stream<A>, E> repeat() {
-    return repeat1().or(() -> value(Stream.<A>nil()));
+    return repeat1().or(() -> value(Stream.nil()));
   }
 
   /**
@@ -345,7 +345,7 @@ public static <I, A, E> Parser<I, A, E> fail(final E e) {
    */
   public static <I, A, E> Parser<I, List<A>, E> sequence(final List<Parser<I, A, E>> ps) {
     return ps.isEmpty() ?
-        Parser.<I, List<A>, E>value(List.<A>nil()) :
+        Parser.value(List.nil()) :
         ps.head().bind(a -> sequence(ps.tail()).map(cons_(a)));
   }
 
@@ -365,8 +365,8 @@ private StreamParser() {
      */
     public static <I, E> Parser<Stream<I>, I, E> element(final F0<E> e) {
       return parser(is -> is.isEmpty() ?
-          Validation.<E, Result<Stream<I>, I>>fail(e.f()) :
-          Validation.<E, Result<Stream<I>, I>>success(result(is.tail()._1(), is.head())));
+          Validation.fail(e.f()) :
+          Validation.success(result(is.tail()._1(), is.head())));
     }
 
     /**
@@ -390,8 +390,8 @@ public static <I, E> Parser<Stream<I>, I, E> element(final E e) {
     public static <I, E> Parser<Stream<I>, I, E> satisfy(final F0<E> missing, final F<I, E> sat,
                                                          final F<I, Boolean> f) {
       return StreamParser.<I, E>element(missing).bind(x -> f.f(x) ?
-          Parser.<Stream<I>, I, E>value(x) :
-          Parser.<Stream<I>, I, E>fail(sat.f(x)));
+          Parser.value(x) :
+          Parser.fail(sat.f(x)));
     }
 
     /**
@@ -470,8 +470,8 @@ public static <E> Parser<Stream<Character>, Character, E> character(final E miss
      */
     public static <E> Parser<Stream<Character>, Stream<Character>, E> characters(final F0<E> missing, final int n) {
       return n <= 0 ?
-          Parser.<Stream<Character>, Stream<Character>, E>value(Stream.<Character>nil()) :
-          character(missing).bind(characters(missing, n - 1), Stream.<Character>cons_());
+          Parser.value(Stream.nil()) :
+          character(missing).bind(characters(missing, n - 1), Stream.cons_());
     }
 
     /**
@@ -497,8 +497,8 @@ public static <E> Parser<Stream<Character>, Stream<Character>, E> characters(fin
                                                                                  final F<Character, E> sat,
                                                                                  final Stream<Character> cs) {
       return cs.isEmpty() ?
-          Parser.<Stream<Character>, Stream<Character>, E>value(Stream.<Character>nil()) :
-          character(missing, sat, cs.head()).bind(characters(missing, sat, cs.tail()._1()), Stream.<Character>cons_());
+          Parser.value(Stream.nil()) :
+          character(missing, sat, cs.head()).bind(characters(missing, sat, cs.tail()._1()), Stream.cons_());
     }
 
     /**
diff --git a/core/src/main/java/fj/parser/Result.java b/core/src/main/java/fj/parser/Result.java
index 8f5a4b78..51e115f6 100644
--- a/core/src/main/java/fj/parser/Result.java
+++ b/core/src/main/java/fj/parser/Result.java
@@ -133,7 +133,7 @@ public void remove() {
    * @return A result with the given remainder of the parse input and parse value.
    */
   public static <A, I> Result<I, A> result(final I i, final A a) {
-    return new Result<I, A>(i, a);
+    return new Result<>(i, a);
   }
 
   /**
diff --git a/demo/src/main/java/fj/demo/ChequeWrite.java b/demo/src/main/java/fj/demo/ChequeWrite.java
index ee958fc9..6e28153c 100644
--- a/demo/src/main/java/fj/demo/ChequeWrite.java
+++ b/demo/src/main/java/fj/demo/ChequeWrite.java
@@ -24,7 +24,7 @@ public final class ChequeWrite {
   private ChequeWrite() {}
 
   static List<Integer> toZero(final int from) {
-    return unfold(i -> i < 0 ? Option.<P2<Integer, Integer>>none() : some(p(i, i - 1)), from);
+    return unfold(i -> i < 0 ? Option.none() : some(p(i, i - 1)), from);
   }
 
   static int signum(final int i) {
@@ -60,9 +60,9 @@ static List<Character> show(final List<Character> cs) {
                    : stringShow.showl(
                        list("twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety").index(
                            d1 - '0' - 2))
-                       .append(d2 == '0' ? List.<Character>nil() : show(d2).cons('-'))
+                       .append(d2 == '0' ? List.nil() : show(d2).cons('-'))
                : d1 == '0' && d2 == '0' && d2r.head() == '0'
-                 ? List.<Character>nil()
+                 ? List.nil()
                  : d1 == '0'
                    ? show(list(d2, d2r.head()))
                    : d2 == '0' && d2r.head() == '0'
@@ -76,7 +76,7 @@ static <A> List<P2<List<A>, Integer>> split(final List<A> as) {
     final int len = as.length();
 
     final List<List<A>> ds = as.zip(toZero(len - 1)).foldRight((ki, z) ->
-        ki._2() % 3 == 0 ? z.conss(single(ki._1())) : z.tail().conss(z.head().cons(ki._1())), List.<List<A>>nil()
+        ki._2() % 3 == 0 ? z.conss(single(ki._1())) : z.tail().conss(z.head().cons(ki._1())), List.nil()
     );
     return ds.zip(toZero(len / 3 + signum(len % 3) - 1));
   }
@@ -106,7 +106,7 @@ static boolean eq(final List<Character> a, final List<Character> b) {
       if (cs.isEmpty())
         return fromString("zero dollars");
       else {
-        final List.Buffer<List<Character>> x = new List.Buffer<List<Character>>();
+        final List.Buffer<List<Character>> x = new List.Buffer<>();
 
         final List<P2<List<Character>, Integer>> k = split(cs);
         final int c = k.head()._2();
diff --git a/demo/src/main/java/fj/demo/Comonad_example.java b/demo/src/main/java/fj/demo/Comonad_example.java
index 9a64c34e..8d5bc683 100644
--- a/demo/src/main/java/fj/demo/Comonad_example.java
+++ b/demo/src/main/java/fj/demo/Comonad_example.java
@@ -22,11 +22,11 @@ public static void main(final String[] args) {
   }
 
   public static Stream<Stream<Character>> perms(final Stream<Character> s) {
-    Stream<Stream<Character>> r = single(Stream.<Character>nil());
+    Stream<Stream<Character>> r = single(Stream.nil());
     for (final Zipper<Character> z : fromStream(s))
       r = join(z.cobind(zp ->
             perms(zp.lefts().reverse().append(zp.rights())).map(
-                F1Functions.o(Stream.<Character>cons().f(zp.focus()), P.<Stream<Character>>p1())
+                F1Functions.o(Stream.<Character>cons().f(zp.focus()), P.p1())
             )
       ).toStream());
     return r;
diff --git a/demo/src/main/java/fj/demo/Option_bind.java b/demo/src/main/java/fj/demo/Option_bind.java
index d02a1493..edf3dd83 100644
--- a/demo/src/main/java/fj/demo/Option_bind.java
+++ b/demo/src/main/java/fj/demo/Option_bind.java
@@ -18,9 +18,9 @@ public static void main(final String[] args) {
         final Option<Integer> o5 = o2.bind(f);
         final Option<Integer> o6 = o3.bind(f);
 
-        final Option<Integer> p1 = o1.bind(i -> i % 2 == 0 ? some(i * 3) : Option.<Integer>none());
-        final Option<Integer> p2 = o2.bind(i -> i % 2 == 0 ? some(i * 3) : Option.<Integer>none());
-        final Option<Integer> p3 = o3.bind(i -> i % 2 == 0 ? some(i * 3) : Option.<Integer>none());
+        final Option<Integer> p1 = o1.bind(i -> i % 2 == 0 ? some(i * 3) : Option.none());
+        final Option<Integer> p2 = o2.bind(i -> i % 2 == 0 ? some(i * 3) : Option.none());
+        final Option<Integer> p3 = o3.bind(i -> i % 2 == 0 ? some(i * 3) : Option.none());
 
         optionShow(intShow).println(o4); // None
         optionShow(intShow).println(o5); // Some(24)
diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index 167a08f5..56763ce5 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -75,7 +75,7 @@ VendingMachine next(Input i) {
 	}
 
 	static State<VendingMachine, VendingMachine> simulate(List<Input> list) {
-		return list.foldLeft((s, i) -> s.map(m -> m.next(i)), State.<VendingMachine>init());
+		return list.foldLeft((s, i) -> s.map(m -> m.next(i)), State.init());
 	}
 
 	static void test() {
diff --git a/demo/src/main/java/fj/demo/concurrent/Fibs.java b/demo/src/main/java/fj/demo/concurrent/Fibs.java
index 5e95e597..e2e94fc8 100644
--- a/demo/src/main/java/fj/demo/concurrent/Fibs.java
+++ b/demo/src/main/java/fj/demo/concurrent/Fibs.java
@@ -52,7 +52,7 @@ public static void main(final String[] args)
           {return n < CUTOFF ? promise(su, P.p(seqFib(n))) : f(n - 1).bind(f(n - 2), add);}};
 
       System.out.println("Calculating Fibonacci sequence in parallel...");
-      join(su, spi.parMap(fib, range(0, 46)).map(Promise.<Integer>sequence(su))).to(out);}
+      join(su, spi.parMap(fib, range(0, 46)).map(Promise.sequence(su))).to(out);}
 
   // The sequential version of the recursive Fibonacci function
   public static int seqFib(final int n)
diff --git a/demo/src/main/java/fj/demo/concurrent/MapReduce.java b/demo/src/main/java/fj/demo/concurrent/MapReduce.java
index 57a59d9e..3cb2d761 100644
--- a/demo/src/main/java/fj/demo/concurrent/MapReduce.java
+++ b/demo/src/main/java/fj/demo/concurrent/MapReduce.java
@@ -64,7 +64,7 @@ public Stream<Character> f(final BufferedReader reader) {
         }));
 
     final ExecutorService pool = newFixedThreadPool(16);
-    final ParModule m = parModule(Strategy.<Unit>executorStrategy(pool));
+    final ParModule m = parModule(Strategy.executorStrategy(pool));
 
     System.out.println("Word Count: " + countWords(documents, m).claim());
 
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index dbbd035c..203b8feb 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -56,7 +56,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
   
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharChunkIteratee = fileName -> {
       try {
-        return IOFunctions.enumFileCharChunks(new File(fileName), Option.<Charset>none(), wordCountsFromCharChunks()).run().run();
+        return IOFunctions.enumFileCharChunks(new File(fileName), Option.none(), wordCountsFromCharChunks()).run().run();
       } catch (final IOException e) {
         throw new RuntimeException(e);
       }
@@ -64,7 +64,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
   
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharChunk2Iteratee = fileName -> {
       try {
-        return IOFunctions.enumFileChars(new File(fileName), Option.<Charset> none(), wordCountsFromChars()).run().run();
+        return IOFunctions.enumFileChars(new File(fileName), Option.none(), wordCountsFromChars()).run().run();
       } catch (final IOException e) {
         throw new RuntimeException(e);
       }
@@ -72,7 +72,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
   
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharIteratee = fileName -> {
       try {
-        return IOFunctions.enumFileChars(new File(fileName), Option.<Charset> none(), wordCountsFromChars()).run().run();
+        return IOFunctions.enumFileChars(new File(fileName), Option.none(), wordCountsFromChars()).run().run();
       } catch (final IOException e) {
         throw new RuntimeException(e);
       }
@@ -115,9 +115,9 @@ public F<char[], IterV<char[], Map<String, Integer>>> _1() {
                 final StringBuilder sb = acc._1();
                 if(sb.length() > 0) {
                   final Map<String, Integer> map = update(acc._2(), sb.toString(), addOne, Integer.valueOf(0));
-                  return IterV.done(map, Input.<char[]>eof());
+                  return IterV.done(map, Input.eof());
                 }
-                return IterV.done(acc._2(), Input.<char[]>eof());
+                return IterV.done(acc._2(), Input.eof());
               });
 
           return s -> s.apply(empty, el, eof);
@@ -157,9 +157,9 @@ public F<Input<Character>, IterV<Character, Map<String, Integer>>> f(final P2<St
                 final StringBuilder sb = acc._1();
                 if(sb.length() > 0) {
                   final Map<String, Integer> map = update(acc._2(), sb.toString(), addOne, Integer.valueOf(0));
-                  return IterV.done(map, Input.<Character>eof());
+                  return IterV.done(map, Input.eof());
                 }
-                return IterV.done(acc._2(), Input.<Character>eof());
+                return IterV.done(acc._2(), Input.eof());
               }
             );
           return s -> s.apply(empty, el, eof);
@@ -268,7 +268,7 @@ private static void print(Map<String, Integer> wordsAndCountsFromFiles) {
 
   private static P2<List<String>, Map<String, Integer>> writeSampleFiles(
       int numFiles, int numSharedWords) throws IOException {
-    final Map<String, Integer> expectedWordsAndCounts = new HashMap<String, Integer>();
+    final Map<String, Integer> expectedWordsAndCounts = new HashMap<>();
     List<String> fileNames = nil();
     for(int i = 0; i < numFiles; i++) {
       final File file = File.createTempFile("wordcount-"+ i + "-", ".txt");
@@ -294,7 +294,7 @@ public static Map<String, Integer> getWordsAndCountsFromFilesWithIteratee(final
   public static Map<String, Integer> getWordsAndCountsFromFilesInParallel(
       final List<String> fileNames, final F<String, Map<String, Integer>> fileNameToWordsAndCounts, int numThreads) {
     final ExecutorService pool = newFixedThreadPool(numThreads);
-    final ParModule m = parModule(Strategy.<Unit> executorStrategy(pool));
+    final ParModule m = parModule(Strategy.executorStrategy(pool));
 
     // Long wordCount = countWords(fileNames.map(readFile), m).claim();    
     final Map<String, Integer> result = getWordsAndCountsFromFiles(fileNames, fileNameToWordsAndCounts, m).claim();
@@ -315,7 +315,7 @@ public static Promise<Map<String, Integer>> getWordsAndCountsFromFiles(
   }
   
   private static Map<String, Integer> plus(Map<String, Integer> a, Map<String, Integer> b) {
-    final Map<String, Integer> result = new HashMap<String, Integer>(a);
+    final Map<String, Integer> result = new HashMap<>(a);
     for(Map.Entry<String, Integer> entry : b.entrySet()) {
       final Integer num = result.get(entry.getKey());
       result.put(entry.getKey(), num != null ? num.intValue() + entry.getValue() : entry.getValue());
diff --git a/demo/src/main/java/fj/demo/test/JavaLinkedList.java b/demo/src/main/java/fj/demo/test/JavaLinkedList.java
index 5ce11fba..ba8ec1f1 100644
--- a/demo/src/main/java/fj/demo/test/JavaLinkedList.java
+++ b/demo/src/main/java/fj/demo/test/JavaLinkedList.java
@@ -17,7 +17,7 @@ public final class JavaLinkedList {
   public static void main(final String[] args) {
     final Property p = property(arbLinkedList(arbInteger), arbLinkedList(arbInteger),
             (x, y) -> {
-        final LinkedList<Integer> xy = new LinkedList<Integer>(x);
+        final LinkedList<Integer> xy = new LinkedList<>(x);
         xy.addAll(y);
         return prop(xy.size() == x.size() + y.size());
     });
diff --git a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
index 8ed7a306..6f17f827 100644
--- a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
+++ b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
@@ -40,7 +40,7 @@ For any list, mapping the identity function (\x -> x) produces the same list.
 @SuppressWarnings("PackageVisibleField")
 @CheckParams(minSuccessful = 1000)
 public final class ListFunctorLaws {
-  final Property identity = property(arbList(arbString), x -> prop(listEqual(stringEqual).eq(x, x.map(Function.<String>identity()))));
+  final Property identity = property(arbList(arbString), x -> prop(listEqual(stringEqual).eq(x, x.map(Function.identity()))));
 
   final Property composition = property(arbF(coarbInteger, arbString), arbF(coarbLong, arbInteger), arbList(arbLong), (f, g, x) -> {
       final List<String> s1 = x.map(compose(f, g));
diff --git a/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java b/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
index 18d1b5d7..5e5550a3 100644
--- a/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
+++ b/demo/src/main/java/fj/demo/test/OptionMonadFunctorLaw.java
@@ -19,7 +19,7 @@ For any Option (o) and any function (f), then calling flatMap on o with a
 */
 public final class OptionMonadFunctorLaw {
   public static void main(final String[] args) {
-    final Property unitMap = property(arbOption(arbInteger), Arbitrary.<Integer, String>arbFInvariant(arbString), (o, f) -> prop(optionEqual(stringEqual).eq(o.bind(andThen(f, Option.<String>some_())), o.map(f))));
+    final Property unitMap = property(arbOption(arbInteger), Arbitrary.<Integer, String>arbFInvariant(arbString), (o, f) -> prop(optionEqual(stringEqual).eq(o.bind(andThen(f, Option.some_())), o.map(f))));
     summary.println(unitMap.minSuccessful(500)); // OK, passed 500 tests.     
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index a9f05549..848585aa 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -97,7 +97,7 @@ private Arbitrary(final Gen<A> gen) {
    * @return A new arbitrary that uses the given generator.
    */
   public static <A> Arbitrary<A> arbitrary(final Gen<A> g) {
-    return new Arbitrary<A>(g);
+    return new Arbitrary<>(g);
   }
 
   /**
@@ -140,7 +140,7 @@ public static <A> Arbitrary<LcgRng> arbLcgRng() {
    * @return An arbitrary for functions.
    */
   public static <A, B> Arbitrary<F<A, B>> arbFInvariant(final Arbitrary<B> a) {
-    return arbitrary(a.gen.map(Function.<A, B>constant()));
+    return arbitrary(a.gen.map(Function.constant()));
   }
 
   /**
@@ -153,7 +153,7 @@ public static <A, B> Arbitrary<F<A, B>> arbFInvariant(final Arbitrary<B> a) {
    */
   public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
                                                        final Arbitrary<C> a) {
-    return arbitrary(arbF(ca, arbF(cb, a)).gen.map(Function.<A, B, C>uncurryF2()));
+    return arbitrary(arbF(ca, arbF(cb, a)).gen.map(Function.uncurryF2()));
   }
 
   /**
@@ -164,7 +164,7 @@ public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, fi
    */
   public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2Invariant(final Arbitrary<C> a) {
     return arbitrary(a.gen.map(
-        compose(Function.<A, B, C>uncurryF2(), compose(Function.<A, F<B, C>>constant(), Function.<B, C>constant()))));
+        compose(Function.uncurryF2(), compose(Function.constant(), Function.constant()))));
   }
 
   /**
@@ -178,7 +178,7 @@ public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2Invariant(final Arbitrary<C>
    */
   public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
                                                              final Coarbitrary<C> cc, final Arbitrary<D> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, a))).gen.map(Function.<A, B, C, D>uncurryF3()));
+    return arbitrary(arbF(ca, arbF(cb, arbF(cc, a))).gen.map(Function.uncurryF3()));
   }
 
   /**
@@ -188,10 +188,10 @@ public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3(final Coarbitrary<A>
    * @return An arbitrary for function-3.
    */
   public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3Invariant(final Arbitrary<D> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D>uncurryF3(), compose(Function.<A, F<B, F<C, D>>>constant(),
+    return arbitrary(a.gen.map(compose(Function.uncurryF3(), compose(Function.constant(),
                                                                                  compose(
-                                                                                     Function.<B, F<C, D>>constant(),
-                                                                                     Function.<C, D>constant())))));
+                                                                                     Function.constant(),
+                                                                                     Function.constant())))));
   }
 
   /**
@@ -207,7 +207,7 @@ public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3Invariant(final Arbitr
   public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
                                                                    final Coarbitrary<C> cc, final Coarbitrary<D> cd,
                                                                    final Arbitrary<E> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, a)))).gen.map(Function.<A, B, C, D, E>uncurryF4()));
+    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, a)))).gen.map(Function.uncurryF4()));
   }
 
   /**
@@ -217,11 +217,11 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4(final Coarbitra
    * @return An arbitrary for function-4.
    */
   public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final Arbitrary<E> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E>uncurryF4(),
-                                       compose(Function.<A, F<B, F<C, F<D, E>>>>constant(),
-                                               compose(Function.<B, F<C, F<D, E>>>constant(),
-                                                       compose(Function.<C, F<D, E>>constant(),
-                                                               Function.<D, E>constant()))))));
+    return arbitrary(a.gen.map(compose(Function.uncurryF4(),
+                                       compose(Function.constant(),
+                                               compose(Function.constant(),
+                                                       compose(Function.constant(),
+                                                               Function.constant()))))));
   }
 
   /**
@@ -242,7 +242,7 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
                                                                            final Coarbitrary<E> ce,
                                                                            final Arbitrary<F$> a) {
     return arbitrary(
-        arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, a))))).gen.map(Function.<A, B, C, D, E, F$>uncurryF5()));
+        arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, a))))).gen.map(Function.uncurryF5()));
   }
 
   /**
@@ -252,12 +252,12 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @return An arbitrary for function-5.
    */
   public static <A, B, C, D, E, F$> Arbitrary<F5<A, B, C, D, E, F$>> arbF5Invariant(final Arbitrary<F$> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$>uncurryF5(),
-                                       compose(Function.<A, F<B, F<C, F<D, F<E, F$>>>>>constant(),
-                                               compose(Function.<B, F<C, F<D, F<E, F$>>>>constant(),
-                                                       compose(Function.<C, F<D, F<E, F$>>>constant(),
-                                                               compose(Function.<D, F<E, F$>>constant(),
-                                                                       Function.<E, F$>constant())))))));
+    return arbitrary(a.gen.map(compose(Function.uncurryF5(),
+                                       compose(Function.constant(),
+                                               compose(Function.constant(),
+                                                       compose(Function.constant(),
+                                                               compose(Function.constant(),
+                                                                       Function.constant())))))));
   }
 
   /**
@@ -280,7 +280,7 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
                                                                                  final Coarbitrary<F$> cf,
                                                                                  final Arbitrary<G> a) {
     return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, a)))))).gen.map(
-        Function.<A, B, C, D, E, F$, G>uncurryF6()));
+        Function.uncurryF6()));
   }
 
   /**
@@ -291,12 +291,12 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    */
   public static <A, B, C, D, E, F$, G> Arbitrary<F6<A, B, C, D, E, F$, G>> arbF6Invariant(final Arbitrary<G> a) {
     return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G>uncurryF6(),
-                                       compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>>constant(),
-                                               compose(Function.<B, F<C, F<D, F<E, F<F$, G>>>>>constant(),
-                                                       compose(Function.<C, F<D, F<E, F<F$, G>>>>constant(),
-                                                               compose(Function.<D, F<E, F<F$, G>>>constant(),
-                                                                       compose(Function.<E, F<F$, G>>constant(),
-                                                                               Function.<F$, G>constant()))))))));
+        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>>constant(),
+            compose(Function.<B, F<C, F<D, F<E, F<F$, G>>>>>constant(),
+                compose(Function.<C, F<D, F<E, F<F$, G>>>>constant(),
+                    compose(Function.<D, F<E, F<F$, G>>>constant(),
+                        compose(Function.<E, F<F$, G>>constant(),
+                            Function.<F$, G>constant()))))))));
   }
 
   /**
@@ -321,7 +321,7 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
                                                                                        final Coarbitrary<G> cg,
                                                                                        final Arbitrary<H> a) {
     return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, a))))))).gen.map(
-        Function.<A, B, C, D, E, F$, G, H>uncurryF7()));
+        Function.uncurryF7()));
   }
 
   /**
@@ -332,13 +332,13 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    */
   public static <A, B, C, D, E, F$, G, H> Arbitrary<F7<A, B, C, D, E, F$, G, H>> arbF7Invariant(final Arbitrary<H> a) {
     return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G, H>uncurryF7(),
-                                       compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>>constant(),
-                                               compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>constant(),
-                                                       compose(Function.<C, F<D, F<E, F<F$, F<G, H>>>>>constant(),
-                                                               compose(Function.<D, F<E, F<F$, F<G, H>>>>constant(),
-                                                                       compose(Function.<E, F<F$, F<G, H>>>constant(),
-                                                                               compose(Function.<F$, F<G, H>>constant(),
-                                                                                       Function.<G, H>constant())))))))));
+        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>>constant(),
+            compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>constant(),
+                compose(Function.<C, F<D, F<E, F<F$, F<G, H>>>>>constant(),
+                    compose(Function.<D, F<E, F<F$, F<G, H>>>>constant(),
+                        compose(Function.<E, F<F$, F<G, H>>>constant(),
+                            compose(Function.<F$, F<G, H>>constant(),
+                                Function.<G, H>constant())))))))));
   }
 
   /**
@@ -365,7 +365,7 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
                                                                                              final Coarbitrary<H> ch,
                                                                                              final Arbitrary<I> a) {
     return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, arbF(ch, a)))))))).gen.map(
-        Function.<A, B, C, D, E, F$, G, H, I>uncurryF8()));
+        Function.uncurryF8()));
   }
 
   /**
@@ -377,16 +377,16 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
   public static <A, B, C, D, E, F$, G, H, I> Arbitrary<F8<A, B, C, D, E, F$, G, H, I>> arbF8Invariant(
       final Arbitrary<I> a) {
     return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G, H, I>uncurryF8(),
-                                       compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>>constant(),
-                                               compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>constant(),
-                                                       compose(Function.<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>constant(),
-                                                               compose(
-                                                                   Function.<D, F<E, F<F$, F<G, F<H, I>>>>>constant(),
-                                                                   compose(Function.<E, F<F$, F<G, F<H, I>>>>constant(),
-                                                                           compose(
-                                                                               Function.<F$, F<G, F<H, I>>>constant(),
-                                                                               compose(Function.<G, F<H, I>>constant(),
-                                                                                       Function.<H, I>constant()))))))))));
+        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>>constant(),
+            compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>constant(),
+                compose(Function.<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>constant(),
+                    compose(
+                        Function.<D, F<E, F<F$, F<G, F<H, I>>>>>constant(),
+                        compose(Function.<E, F<F$, F<G, F<H, I>>>>constant(),
+                            compose(
+                                Function.<F$, F<G, F<H, I>>>constant(),
+                                compose(Function.<G, F<H, I>>constant(),
+                                    Function.<H, I>constant()))))))))));
   }
 
   /**
@@ -619,7 +619,7 @@ public static <A> Arbitrary<Gen<A>> arbGen(final Arbitrary<A> aa) {
    */
   public static <A> Arbitrary<Option<A>> arbOption(final Arbitrary<A> aa) {
     return arbitrary(sized(i -> i == 0 ?
-           value(Option.<A>none()) :
+           value(Option.none()) :
            aa.gen.map(Option::some).resize(i - 1)));
   }
 
@@ -695,7 +695,7 @@ public static <A, B> Arbitrary<Validation<A, B>> arbValidation(final Arbitrary<A
    * @return An arbitrary implementation for streams.
    */
   public static <A> Arbitrary<Stream<A>> arbStream(final Arbitrary<A> aa) {
-    return arbitrary(arbList(aa).gen.map(List<A>::toStream));
+    return arbitrary(arbList(aa).gen.map(List::toStream));
   }
 
   /**
@@ -753,7 +753,7 @@ public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
    * @return An arbitrary implementation for array lists.
    */
   public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new ArrayList<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new ArrayList<>(a.toCollection())));
   }
 
   /**
@@ -842,7 +842,7 @@ public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak,
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.toCollection())));
   }
 
   /**
@@ -856,7 +856,7 @@ public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
    */
   public static <K, V> Arbitrary<Hashtable<K, V>> arbHashtable(final Arbitrary<K> ak, final Arbitrary<V> av) {
     return arbitrary(arbList(ak).gen.bind(arbList(av).gen, ks -> vs -> {
-      final Hashtable<K, V> t = new Hashtable<K, V>();
+      final Hashtable<K, V> t = new Hashtable<>();
 
       ks.zip(vs).foreachDoEffect(kv -> t.put(kv._1(), kv._2()));
 
@@ -898,7 +898,7 @@ public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbit
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.toCollection())));
   }
 
   /**
@@ -908,7 +908,7 @@ public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A
    * @return An arbitrary implementation for linked lists.
    */
   public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.toCollection())));
   }
 
   /**
@@ -918,7 +918,7 @@ public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa)
    * @return An arbitrary implementation for priority queues.
    */
   public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.toCollection())));
   }
 
   /**
@@ -943,7 +943,7 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
    */
   public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.map(a -> {
-      final Stack<A> s = new Stack<A>();
+      final Stack<A> s = new Stack<>();
       s.addAll(a.toCollection());
       return s;
     }));
@@ -1005,7 +1005,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
    * @return An arbitrary implementation for tree sets.
    */
   public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.toCollection())));
   }
 
   /**
@@ -1016,7 +1016,7 @@ public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
    */
   @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new Vector<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.toCollection())));
   }
 
   /**
@@ -1071,7 +1071,7 @@ public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(fin
    * @return An arbitrary implementation for concurrent linked queues.
    */
   public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.toCollection())));
   }
 
   /**
@@ -1082,7 +1082,7 @@ public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(f
    * @return An arbitrary implementation for copy-on-write array lists.
    */
   public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.toCollection())));
   }
 
   /**
@@ -1093,7 +1093,7 @@ public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(fin
    * @return An arbitrary implementation for copy-on-write array sets.
    */
   public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.toCollection())));
   }
 
   /**
@@ -1103,7 +1103,7 @@ public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final
    * @return An arbitrary implementation for delay queues.
    */
   public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.toCollection())));
   }
 
   /**
@@ -1114,7 +1114,7 @@ public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final A
    * @return An arbitrary implementation for linked blocking queues.
    */
   public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.toCollection())));
   }
 
   /**
@@ -1125,7 +1125,7 @@ public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final
    * @return An arbitrary implementation for priority blocking queues.
    */
   public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<A>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.toCollection())));
   }
 
   /**
@@ -1137,7 +1137,7 @@ public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(f
    */
   public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, a -> fair -> {
-      final SynchronousQueue<A> q = new SynchronousQueue<A>(fair);
+      final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(a.toCollection());
       return q;
     }));
diff --git a/quickcheck/src/main/java/fj/test/Arg.java b/quickcheck/src/main/java/fj/test/Arg.java
index 337f8027..4187c15d 100644
--- a/quickcheck/src/main/java/fj/test/Arg.java
+++ b/quickcheck/src/main/java/fj/test/Arg.java
@@ -28,7 +28,7 @@ private Arg(final T value, final int shrinks) {
    * @return A new argument.
    */
   public static <T> Arg<T> arg(final T value, final int shrinks) {
-    return new Arg<T>(value, shrinks);
+    return new Arg<>(value, shrinks);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/CheckResult.java b/quickcheck/src/main/java/fj/test/CheckResult.java
index dc0195d7..718daf03 100644
--- a/quickcheck/src/main/java/fj/test/CheckResult.java
+++ b/quickcheck/src/main/java/fj/test/CheckResult.java
@@ -55,7 +55,7 @@ private CheckResult(final R r, final Option<List<Arg<?>>> args, final Option<Thr
    * @return A result that the property has passed.
    */
   public static CheckResult passed(final int succeeded, final int discarded) {
-    return new CheckResult(R.Passed, Option.<List<Arg<?>>>none(), Option.<Throwable>none(), succeeded, discarded);
+    return new CheckResult(R.Passed, Option.none(), Option.none(), succeeded, discarded);
   }
 
   /**
@@ -67,7 +67,7 @@ public static CheckResult passed(final int succeeded, final int discarded) {
    * @return A result that the property has been proven.
    */
   public static CheckResult proven(final List<Arg<?>> args, final int succeeded, final int discarded) {
-    return new CheckResult(R.Proven, some(args), Option.<Throwable>none(), succeeded, discarded);
+    return new CheckResult(R.Proven, some(args), Option.none(), succeeded, discarded);
   }
 
   /**
@@ -79,7 +79,7 @@ public static CheckResult proven(final List<Arg<?>> args, final int succeeded, f
    * @return A result that the property has been falsified.
    */
   public static CheckResult falsified(final List<Arg<?>> args, final int succeeded, final int discarded) {
-    return new CheckResult(R.Falsified, some(args), Option.<Throwable>none(), succeeded, discarded);
+    return new CheckResult(R.Falsified, some(args), Option.none(), succeeded, discarded);
   }
 
   /**
@@ -90,7 +90,7 @@ public static CheckResult falsified(final List<Arg<?>> args, final int succeeded
    * @return A result that the property has been exhausted in checking.
    */
   public static CheckResult exhausted(final int succeeded, final int discarded) {
-    return new CheckResult(R.Exhausted, Option.<List<Arg<?>>>none(), Option.<Throwable>none(), succeeded, discarded);
+    return new CheckResult(R.Exhausted, Option.none(), Option.none(), succeeded, discarded);
   }
 
   /**
@@ -117,7 +117,7 @@ public static CheckResult propException(final List<Arg<?>> args, final Throwable
    * @return A result that generating values to check the property threw an exception.
    */
   public static CheckResult genException(final Throwable ex, final int succeeded, final int discarded) {
-    return new CheckResult(R.GenException, Option.<List<Arg<?>>>none(), some(ex), succeeded, discarded);
+    return new CheckResult(R.GenException, Option.none(), some(ex), succeeded, discarded);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index 9655aec2..cd519513 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -574,7 +574,7 @@ public static <K extends Enum<K>, V> Coarbitrary<EnumMap<K, V>> coarbEnumMap(fin
     return new Coarbitrary<EnumMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final EnumMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -589,7 +589,7 @@ public static <A extends Enum<A>> Coarbitrary<EnumSet<A>> coarbEnumSet(final Coa
     return new Coarbitrary<EnumSet<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final EnumSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
+        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
       }
     };
   }
@@ -614,7 +614,7 @@ public static <K, V> Coarbitrary<HashMap<K, V>> coarbHashMap(final Coarbitrary<K
     return new Coarbitrary<HashMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final HashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -668,7 +668,7 @@ public static <K, V> Coarbitrary<IdentityHashMap<K, V>> coarbIdentityHashMap(fin
     return new Coarbitrary<IdentityHashMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final IdentityHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -685,7 +685,7 @@ public static <K, V> Coarbitrary<LinkedHashMap<K, V>> coarbLinkedHashMap(final C
     return new Coarbitrary<LinkedHashMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final LinkedHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -700,7 +700,7 @@ public static <A> Coarbitrary<LinkedHashSet<A>> coarbLinkedHashSet(final Coarbit
     return new Coarbitrary<LinkedHashSet<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedHashSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
+        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
       }
     };
   }
@@ -741,7 +741,7 @@ public <B> Gen<B> coarbitrary(final PriorityQueue<A> as, final Gen<B> g) {
   public static final Coarbitrary<Properties> coarbProperties = new Coarbitrary<Properties>() {
     @SuppressWarnings("UseOfObsoleteCollectionType")
     public <B> Gen<B> coarbitrary(final Properties p, final Gen<B> g) {
-      final Hashtable<String, String> t = new Hashtable<String, String>();
+      final Hashtable<String, String> t = new Hashtable<>();
 
       for (final Object s : p.keySet()) {
         t.put((String) s, p.getProperty((String) s));
@@ -777,7 +777,7 @@ public static <K, V> Coarbitrary<TreeMap<K, V>> coarbTreeMap(final Coarbitrary<K
     return new Coarbitrary<TreeMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final TreeMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -792,7 +792,7 @@ public static <A> Coarbitrary<TreeSet<A>> coarbTreeSet(final Coarbitrary<A> c) {
     return new Coarbitrary<TreeSet<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final TreeSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<A>(as), g);
+        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
       }
     };
   }
@@ -824,7 +824,7 @@ public static <K, V> Coarbitrary<WeakHashMap<K, V>> coarbWeakHashMap(final Coarb
     return new Coarbitrary<WeakHashMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final WeakHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
@@ -860,7 +860,7 @@ public static <K, V> Coarbitrary<ConcurrentHashMap<K, V>> coarbConcurrentHashMap
     return new Coarbitrary<ConcurrentHashMap<K, V>>() {
       @SuppressWarnings("UseOfObsoleteCollectionType")
       public <B> Gen<B> coarbitrary(final ConcurrentHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<K, V>(m), g);
+        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
       }
     };
   }
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 45a4429a..0ffed76a 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -110,7 +110,7 @@ public A gen(final int i, final Rand r) {
    * @return A new generator after applying the mapping function.
    */
   public <B> Gen<B> map(final F<A, B> f) {
-    return new Gen<B>(i -> r -> f.f(gen(i, r)));
+    return new Gen<>(i -> r -> f.f(gen(i, r)));
   }
 
   /**
@@ -161,7 +161,7 @@ public void foreachDoEffect(final Integer i, final Rand r, final Effect1<A> f) {
    * @return A new generator after binding the given function.
    */
   public <B> Gen<B> bind(final F<A, Gen<B>> f) {
-    return new Gen<B>(i -> r -> f.f(gen(i, r)).f.f(i).f(r));
+    return new Gen<>(i -> r -> f.f(gen(i, r)).f.f(i).f(r));
   }
 
   /**
@@ -286,7 +286,7 @@ public <B> Gen<B> apply(final Gen<F<A, B>> gf) {
    * @return A new generator that uses the given size.
    */
   public Gen<A> resize(final int s) {
-    return new Gen<A>(i -> r -> f.f(s).f(r));
+    return new Gen<>(i -> r -> f.f(s).f(r));
   }
 
   /**
@@ -296,7 +296,7 @@ public Gen<A> resize(final int s) {
    * @return A new generator that uses the given function.
    */
   public static <A> Gen<A> gen(final F<Integer, F<Rand, A>> f) {
-    return new Gen<A>(f);
+    return new Gen<>(f);
   }
 
   /**
@@ -328,7 +328,7 @@ public static <A> Gen<List<A>> sequenceN(final int n, final Gen<A> g) {
    * @return A new generator.
    */
   public static <A> Gen<A> parameterised(final F<Integer, F<Rand, Gen<A>>> f) {
-    return new Gen<A>(curry((i, r) -> f.f(i).f(r).gen(i, r)));
+    return new Gen<>(curry((i, r) -> f.f(i).f(r).gen(i, r)));
   }
 
   /**
@@ -338,7 +338,7 @@ public static <A> Gen<A> parameterised(final F<Integer, F<Rand, Gen<A>>> f) {
    * @return A new generator.
    */
   public static <A> Gen<A> sized(final F<Integer, Gen<A>> f) {
-    return parameterised(flip(Function.<Rand, F<Integer, Gen<A>>>constant(f)));
+    return parameterised(flip(Function.constant(f)));
   }
 
   /**
@@ -348,7 +348,7 @@ public static <A> Gen<A> sized(final F<Integer, Gen<A>> f) {
    * @return A generator that always produces the given value.
    */
   public static <A> Gen<A> value(final A a) {
-    return new Gen<A>(i -> r -> a);
+    return new Gen<>(i -> r -> a);
   }
 
   /**
@@ -383,7 +383,7 @@ public static Gen<Double> choose(final double from, final double to) {
    * @return A generator that never returns a value.
    */
   public static <A> Gen<A> fail() {
-    return new Gen<A>(i -> r -> {
+    return new Gen<>(i -> r -> {
       throw error("Failing generator");
     });
   }
@@ -395,7 +395,7 @@ public static <A> Gen<A> fail() {
    * @return A new generator after joining the given generator.
    */
   public static <A> Gen<A> join(final Gen<Gen<A>> g) {
-    return g.bind(Function.<Gen<A>>identity());
+    return g.bind(Function.identity());
   }
 
   /**
@@ -443,7 +443,7 @@ public static <A> Gen<A> elemFrequency(final List<P2<Integer, A>> as) {
    */
   @SafeVarargs
   public static <A> Gen<A> elements(final A... as) {
-    return array(as).isEmpty() ? Gen.<A>fail() : choose(0, as.length - 1).map(i -> as[i]);
+    return array(as).isEmpty() ? Gen.fail() : choose(0, as.length - 1).map(i -> as[i]);
   }
 
   /**
@@ -455,7 +455,7 @@ public static <A> Gen<A> elements(final A... as) {
    *         requests.
    */
   public static <A> Gen<A> oneOf(final List<Gen<A>> gs) {
-    return gs.isEmpty() ? Gen.<A>fail() : choose(0, gs.length() - 1).bind(gs::index);
+    return gs.isEmpty() ? Gen.fail() : choose(0, gs.length() - 1).bind(gs::index);
   }
 
   /**
@@ -723,6 +723,6 @@ public static <A> Gen<List<A>> someWordOf(int maxLength, List<A> as) {
    * @return A generator for functions.
    */
   public static <A, B> Gen<F<A, B>> promote(final F<A, Gen<B>> f) {
-    return new Gen<F<A, B>>(i -> r -> a -> f.f(a).f.f(i).f(r));
+    return new Gen<>(i -> r -> a -> f.f(a).f.f(i).f(r));
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index d69d0c65..274a7453 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -368,7 +368,7 @@ public static Property prop(final Result r) {
    *         otherwise.
    */
   public static Property prop(final boolean b) {
-    return b ? prop(Result.proven(List.<Arg<?>>nil())) : prop(Result.falsified(List.<Arg<?>>nil()));
+    return b ? prop(Result.proven(List.nil())) : prop(Result.falsified(List.nil()));
   }
 
   /**
@@ -471,7 +471,7 @@ public static <A> Property property(final Arbitrary<A> aa, final Shrink<A> sa, f
    *         application of its arguments.
    */
   public static <A> Property propertyP(final Arbitrary<A> aa, final F<A, P1<Property>> f) {
-    return propertyP(aa, Shrink.<A>empty(), f);
+    return propertyP(aa, Shrink.empty(), f);
   }
 
   /**
@@ -521,7 +521,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    *         application of its arguments.
    */
   public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, Property>> f) {
-    return propertyP(aa, ab, sa, sb, compose2(P.<Property>p1(), f));
+    return propertyP(aa, ab, sa, sb, compose2(P.p1(), f));
   }
 
   /**
@@ -549,7 +549,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    *         application of its arguments.
    */
   public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, Property>> f) {
-    return propertyP(aa, ab, compose2(P.<Property>p1(), f));
+    return propertyP(aa, ab, compose2(P.p1(), f));
   }
 
   /**
@@ -581,7 +581,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    *         application of its arguments.
    */
   public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, Property> f) {
-    return propertyP(aa, ab, sa, sb, compose2(P.<Property>p1(), curry(f)));
+    return propertyP(aa, ab, sa, sb, compose2(P.p1(), curry(f)));
   }
 
   /**
@@ -609,7 +609,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    *         application of its arguments.
    */
   public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F2<A, B, Property> f) {
-    return propertyP(aa, ab, compose2(P.<Property>p1(), curry(f)));
+    return propertyP(aa, ab, compose2(P.p1(), curry(f)));
   }
 
   /**
@@ -1320,7 +1320,7 @@ public static Property exception(final F0<Property> p) {
     try {
       return p.f();
     } catch (final Throwable t) {
-      return new Property(i -> r -> Result.exception(List.<Arg<?>>nil(), t));
+      return new Property(i -> r -> Result.exception(List.nil(), t));
     }
   }
 
diff --git a/quickcheck/src/main/java/fj/test/Rand.java b/quickcheck/src/main/java/fj/test/Rand.java
index 567dba77..97f94596 100644
--- a/quickcheck/src/main/java/fj/test/Rand.java
+++ b/quickcheck/src/main/java/fj/test/Rand.java
@@ -52,7 +52,7 @@ public int choose(final long seed, final int from, final int to) {
    * @return A random value in the given range.
    */
   public int choose(final int from, final int to) {
-    return f.f(Option.<Long>none()).f(from).f(to);
+    return f.f(Option.none()).f(from).f(to);
   }
 
   /**
@@ -75,7 +75,7 @@ public double choose(final long seed, final double from, final double to) {
    * @return A random value in the given range.
    */
   public double choose(final double from, final double to) {
-    return g.f(Option.<Long>none()).f(from).f(to);
+    return g.f(Option.none()).f(from).f(to);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Result.java b/quickcheck/src/main/java/fj/test/Result.java
index 467e2ae2..8ad743bb 100644
--- a/quickcheck/src/main/java/fj/test/Result.java
+++ b/quickcheck/src/main/java/fj/test/Result.java
@@ -165,7 +165,7 @@ public static Result noResult(final Option<Result> r) {
    * @return A result representing no result.
    */
   public static Result noResult() {
-    return new Result(Option.<List<Arg<?>>>none(), R.NoResult, Option.<Throwable>none());
+    return new Result(Option.none(), R.NoResult, Option.none());
   }
 
   /**
@@ -175,7 +175,7 @@ public static Result noResult() {
    * @return An unfalsified result.
    */
   public static Result unfalsified(final List<Arg<?>> args) {
-    return new Result(some(args), R.Unfalsified, Option.<Throwable>none());
+    return new Result(some(args), R.Unfalsified, Option.none());
   }
 
   /**
@@ -185,7 +185,7 @@ public static Result unfalsified(final List<Arg<?>> args) {
    * @return A falsified result.
    */
   public static Result falsified(final List<Arg<?>> args) {
-    return new Result(some(args), R.Falsified, Option.<Throwable>none());
+    return new Result(some(args), R.Falsified, Option.none());
   }
 
   /**
@@ -195,7 +195,7 @@ public static Result falsified(final List<Arg<?>> args) {
    * @return A proven result.
    */
   public static Result proven(final List<Arg<?>> args) {
-    return new Result(some(args), R.Proven, Option.<Throwable>none());
+    return new Result(some(args), R.Proven, Option.none());
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 751a1307..46ca3380 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -119,7 +119,7 @@ public <B> Shrink<B> map(final F<A, B> f, final F<B, A> g) {
    *         value.
    */
   public static <A> Shrink<A> shrink(final F<A, Stream<A>> f) {
-    return new Shrink<A>(f);
+    return new Shrink<>(f);
   }
 
   /**
@@ -148,7 +148,7 @@ public static <A> Shrink<A> empty() {
    * A shrink strategy for booleans using false as the bottom of the shrink.
    */
   public static final Shrink<Boolean> shrinkBoolean =
-      shrink(Function.<Boolean, Stream<Boolean>>constant(Stream.single(false)));
+      shrink(Function.constant(Stream.single(false)));
 
   /**
    * A shrink strategy for integers using 0 as the bottom of the shrink.
@@ -189,8 +189,8 @@ public static <A> Shrink<A> empty() {
    */
   public static <A> Shrink<Option<A>> shrinkOption(final Shrink<A> sa) {
     return shrink(o -> o.isNone() ?
-           Stream.<Option<A>>nil() :
-           cons(Option.<A>none(), () -> sa.shrink(o.some()).map(Option.<A>some_())));
+           Stream.nil() :
+           cons(Option.none(), () -> sa.shrink(o.some()).map(Option.some_())));
   }
 
   /**
@@ -202,8 +202,8 @@ public static <A> Shrink<Option<A>> shrinkOption(final Shrink<A> sa) {
    */
   public static <A, B> Shrink<Either<A, B>> shrinkEither(final Shrink<A> sa, final Shrink<B> sb) {
     return shrink(e -> e.isLeft() ?
-           sa.shrink(e.left().value()).map(Either.<A, B>left_()) :
-           sb.shrink(e.right().value()).map(Either.<A, B>right_()));
+           sa.shrink(e.left().value()).map(Either.left_()) :
+           sb.shrink(e.right().value()).map(Either.right_()));
   }
 
   /**
@@ -218,7 +218,7 @@ Stream<List<A>> removeChunks(final int n, final List<A> as) {
         if (as.isEmpty())
           return nil();
         else if (as.tail().isEmpty())
-          return cons(List.<A>nil(), Stream.<List<A>>nil_());
+          return cons(List.nil(), Stream.nil_());
         else {
           final int n1 = n / 2;
           final int n2 = n - n1;
@@ -263,7 +263,7 @@ Stream<List<A>> shrinkOne(final List<A> as) {
    * @return A shrink strategy for arrays.
    */
   public static <A> Shrink<Array<A>> shrinkArray(final Shrink<A> sa) {
-    return shrinkList(sa).map(Conversions.<A>List_Array(), Conversions.<A>Array_List());
+    return shrinkList(sa).map(Conversions.List_Array(), Conversions.Array_List());
   }
 
   /**
@@ -273,7 +273,7 @@ public static <A> Shrink<Array<A>> shrinkArray(final Shrink<A> sa) {
    * @return A shrink strategy for streams.
    */
   public static <A> Shrink<Stream<A>> shrinkStream(final Shrink<A> sa) {
-    return shrinkList(sa).map(Conversions.<A>List_Stream(), Conversions.<A>Stream_List());
+    return shrinkList(sa).map(Conversions.List_Stream(), Conversions.Stream_List());
   }
 
   /**
@@ -318,7 +318,7 @@ public static Shrink<Throwable> shrinkThrowable(final Shrink<String> ss) {
    * @return A shrink strategy for array lists.
    */
   public static <A> Shrink<ArrayList<A>> shrinkArrayList(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_ArrayList(), Java.<A>ArrayList_List());
+    return shrinkList(sa).map(Java.List_ArrayList(), Java.ArrayList_List());
   }
 
   /**
@@ -361,7 +361,7 @@ public static <K extends Enum<K>, V> Shrink<EnumMap<K, V>> shrinkEnumMap(final S
    * @return A shrink strategy for enum sets.
    */
   public static <A extends Enum<A>> Shrink<EnumSet<A>> shrinkEnumSet(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_EnumSet(), Java.<A>EnumSet_List());
+    return shrinkList(sa).map(Java.List_EnumSet(), Java.EnumSet_List());
   }
 
   /**
@@ -392,7 +392,7 @@ public static <K, V> Shrink<HashMap<K, V>> shrinkHashMap(final Shrink<K> sk, fin
    * @return A shrink strategy for hash sets.
    */
   public static <A> Shrink<HashSet<A>> shrinkHashSet(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_HashSet(), Java.<A>HashSet_List());
+    return shrinkList(sa).map(Java.List_HashSet(), Java.HashSet_List());
   }
 
   /**
@@ -405,7 +405,7 @@ public static <A> Shrink<HashSet<A>> shrinkHashSet(final Shrink<A> sa) {
   @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <K, V> Shrink<Hashtable<K, V>> shrinkHashtable(final Shrink<K> sk, final Shrink<V> sv) {
     return shrinkList(shrinkP2(sk, sv)).map(kvs -> {
-      final Hashtable<K, V> h = new Hashtable<K, V>();
+      final Hashtable<K, V> h = new Hashtable<>();
       kvs.foreachDoEffect(kv -> h.put(kv._1(), kv._2()));
       return h;
     }, h -> {
@@ -448,7 +448,7 @@ public static <K, V> Shrink<LinkedHashMap<K, V>> shrinkLinkedHashMap(final Shrin
    * @return A shrink strategy for linked hash sets.
    */
   public static <A> Shrink<LinkedHashSet<A>> shrinkLinkedHashSet(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_LinkedHashSet(), Java.<A>LinkedHashSet_List());
+    return shrinkList(sa).map(Java.List_LinkedHashSet(), Java.LinkedHashSet_List());
   }
 
   /**
@@ -458,7 +458,7 @@ public static <A> Shrink<LinkedHashSet<A>> shrinkLinkedHashSet(final Shrink<A> s
    * @return A shrink strategy for linked lists.
    */
   public static <A> Shrink<LinkedList<A>> shrinkLinkedList(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_LinkedList(), Java.<A>LinkedList_List());
+    return shrinkList(sa).map(Java.List_LinkedList(), Java.LinkedList_List());
   }
 
   /**
@@ -468,7 +468,7 @@ public static <A> Shrink<LinkedList<A>> shrinkLinkedList(final Shrink<A> sa) {
    * @return A shrink strategy for priority queues.
    */
   public static <A> Shrink<PriorityQueue<A>> shrinkPriorityQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_PriorityQueue(), Java.<A>PriorityQueue_List());
+    return shrinkList(sa).map(Java.List_PriorityQueue(), Java.PriorityQueue_List());
   }
 
   /**
@@ -484,7 +484,7 @@ public static <A> Shrink<PriorityQueue<A>> shrinkPriorityQueue(final Shrink<A> s
 
         return p;
       }, p -> {
-        final Hashtable<String, String> t = new Hashtable<String, String>();
+        final Hashtable<String, String> t = new Hashtable<>();
 
         for (final Object s : p.keySet()) {
           t.put((String) s, p.getProperty((String) s));
@@ -500,7 +500,7 @@ public static <A> Shrink<PriorityQueue<A>> shrinkPriorityQueue(final Shrink<A> s
    * @return A shrink strategy for stacks.
    */
   public static <A> Shrink<Stack<A>> shrinkStack(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_Stack(), Java.<A>Stack_List());
+    return shrinkList(sa).map(Java.List_Stack(), Java.Stack_List());
   }
 
   /**
@@ -521,7 +521,7 @@ public static <K, V> Shrink<TreeMap<K, V>> shrinkTreeMap(final Shrink<K> sk, fin
    * @return A shrink strategy for tree sets.
    */
   public static <A> Shrink<TreeSet<A>> shrinkTreeSet(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_TreeSet(), Java.<A>TreeSet_List());
+    return shrinkList(sa).map(Java.List_TreeSet(), Java.TreeSet_List());
   }
 
   /**
@@ -531,7 +531,7 @@ public static <A> Shrink<TreeSet<A>> shrinkTreeSet(final Shrink<A> sa) {
    * @return A shrink strategy for vectors.
    */
   public static <A> Shrink<Vector<A>> shrinkVector(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_Vector(), Java.<A>Vector_List());
+    return shrinkList(sa).map(Java.List_Vector(), Java.Vector_List());
   }
 
   /**
@@ -556,7 +556,7 @@ public static <K, V> Shrink<WeakHashMap<K, V>> shrinkWeakHashMap(final Shrink<K>
    * @return A shrink strategy for array blocking queues.
    */
   public static <A> Shrink<ArrayBlockingQueue<A>> shrinkArrayBlockingQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_ArrayBlockingQueue(false), Java.<A>ArrayBlockingQueue_List());
+    return shrinkList(sa).map(Java.List_ArrayBlockingQueue(false), Java.ArrayBlockingQueue_List());
   }
 
   /**
@@ -577,7 +577,7 @@ public static <K, V> Shrink<ConcurrentHashMap<K, V>> shrinkConcurrentHashMap(fin
    * @return A shrink strategy for concurrent linked queues.
    */
   public static <A> Shrink<ConcurrentLinkedQueue<A>> shrinkConcurrentLinkedQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_ConcurrentLinkedQueue(), Java.<A>ConcurrentLinkedQueue_List());
+    return shrinkList(sa).map(Java.List_ConcurrentLinkedQueue(), Java.ConcurrentLinkedQueue_List());
   }
 
   /**
@@ -587,7 +587,7 @@ public static <A> Shrink<ConcurrentLinkedQueue<A>> shrinkConcurrentLinkedQueue(f
    * @return A shrink strategy for copy on write array lists.
    */
   public static <A> Shrink<CopyOnWriteArrayList<A>> shrinkCopyOnWriteArrayList(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_CopyOnWriteArrayList(), Java.<A>CopyOnWriteArrayList_List());
+    return shrinkList(sa).map(Java.List_CopyOnWriteArrayList(), Java.CopyOnWriteArrayList_List());
   }
 
   /**
@@ -597,7 +597,7 @@ public static <A> Shrink<CopyOnWriteArrayList<A>> shrinkCopyOnWriteArrayList(fin
    * @return A shrink strategy for copy on write array sets.
    */
   public static <A> Shrink<CopyOnWriteArraySet<A>> shrinkCopyOnWriteArraySet(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_CopyOnWriteArraySet(), Java.<A>CopyOnWriteArraySet_List());
+    return shrinkList(sa).map(Java.List_CopyOnWriteArraySet(), Java.CopyOnWriteArraySet_List());
   }
 
   /**
@@ -607,7 +607,7 @@ public static <A> Shrink<CopyOnWriteArraySet<A>> shrinkCopyOnWriteArraySet(final
    * @return A shrink strategy for delay queues.
    */
   public static <A extends Delayed> Shrink<DelayQueue<A>> shrinkDelayQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_DelayQueue(), Java.<A>DelayQueue_List());
+    return shrinkList(sa).map(Java.List_DelayQueue(), Java.DelayQueue_List());
   }
 
   /**
@@ -617,7 +617,7 @@ public static <A extends Delayed> Shrink<DelayQueue<A>> shrinkDelayQueue(final S
    * @return A shrink strategy for linked blocking queues.
    */
   public static <A> Shrink<LinkedBlockingQueue<A>> shrinkLinkedBlockingQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_LinkedBlockingQueue(), Java.<A>LinkedBlockingQueue_List());
+    return shrinkList(sa).map(Java.List_LinkedBlockingQueue(), Java.LinkedBlockingQueue_List());
   }
 
   /**
@@ -627,7 +627,7 @@ public static <A> Shrink<LinkedBlockingQueue<A>> shrinkLinkedBlockingQueue(final
    * @return A shrink strategy for priority blocking queues.
    */
   public static <A> Shrink<PriorityBlockingQueue<A>> shrinkPriorityBlockingQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_PriorityBlockingQueue(), Java.<A>PriorityBlockingQueue_List());
+    return shrinkList(sa).map(Java.List_PriorityBlockingQueue(), Java.PriorityBlockingQueue_List());
   }
 
   /**
@@ -637,7 +637,7 @@ public static <A> Shrink<PriorityBlockingQueue<A>> shrinkPriorityBlockingQueue(f
    * @return A shrink strategy for synchronous queues.
    */
   public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrink<A> sa) {
-    return shrinkList(sa).map(Java.<A>List_SynchronousQueue(false), Java.<A>SynchronousQueue_List());
+    return shrinkList(sa).map(Java.List_SynchronousQueue(false), Java.SynchronousQueue_List());
   }
 
   // END java.util.concurrent
diff --git a/quickcheck/src/main/java/fj/test/Variant.java b/quickcheck/src/main/java/fj/test/Variant.java
index f50bf923..a0ef3276 100644
--- a/quickcheck/src/main/java/fj/test/Variant.java
+++ b/quickcheck/src/main/java/fj/test/Variant.java
@@ -11,7 +11,7 @@
  * @version %build.number%
  */
 public final class Variant {
-  private static final HashMap<LongGen, Gen<?>> variantMemo = new HashMap<LongGen, Gen<?>>();
+  private static final HashMap<LongGen, Gen<?>> variantMemo = new HashMap<>();
 
   private static final class LongGen {
     private final long n;
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index f4da2459..eb865e04 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -264,7 +264,7 @@ private static <T> Array<P3<Property, String, Option<CheckParams>>> properties(f
       @SuppressWarnings("unchecked")
       final List<Boolean> bss = somes(list(fromNull(e.getAnnotation(Category.class)).map(p1),
         fromNull(declaringClass.getAnnotation(Category.class)).map(p1)));
-      return bss.exists(Function.<Boolean>identity());
+      return bss.exists(Function.identity());
     };
 
     final F<Name, String> nameS = Name::value;
@@ -281,7 +281,7 @@ private static <T> Array<P3<Property, String, Option<CheckParams>>> properties(f
       try {
         final Option<CheckParams> params = fromNull(m.element().getAnnotation(CheckParams.class)).orElse(fromNull(declaringClass.getAnnotation(CheckParams.class)));
         final String name = fromNull(m.element().getAnnotation(Name.class)).map(nameS).orSome(m.name());
-        return p(m.invoke(t.orSome(P.<T>p(null))), name, params);
+        return p(m.invoke(t.orSome(P.p(null))), name, params);
       } catch(Exception e) {
         throw new Error(e.getMessage(), e);
       }

From 1830edcf4a29bf4f5a55397c7ae9f660ed33ec48 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 08:16:39 +0100
Subject: [PATCH 046/336] Use simpler foreach instead of for loop

---
 core/src/main/java/fj/data/IOFunctions.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index cfe5eba2..1440b692 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -283,10 +283,10 @@ public IO<IterV<Character, A>> f(final IterV<Character, A> it) {
                         if (numRead < buffer.length) {
                             buffer = Arrays.copyOfRange(buffer, 0, numRead);
                         }
-                        for (int c = 0; c < buffer.length; c++) {
-                            final Input<Character> input = Input.el(buffer[c]);
+                        for (char c : buffer) {
+                            final Input<Character> input = Input.el(c);
                             final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
-                                    Function.apply(input);
+                                Function.apply(input);
                             i = i.fold(done, cont);
                         }
                     }

From 06d0257b3fda740c28284f41fe8985ca2e2fc437 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 08:29:26 +0100
Subject: [PATCH 047/336] Add missing type parameter

---
 core/src/main/java/fj/data/DList.java | 2 +-
 core/src/main/java/fj/data/Set.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index cf2f0af5..af9d68b0 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -75,7 +75,7 @@ public List<A> run() {
     /**
      * Converts the DList to a standard java.util.List.
      */
-    public java.util.List toJavaList() {
+    public java.util.List<A> toJavaList() {
         return run().toJavaList();
     }
     
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 5bb902d6..42ce0bac 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -323,7 +323,7 @@ public final java.util.TreeSet<A> toJavaTreeSet() {
    *
    * @return a java.util.List representation of this set.
    */
-  public final java.util.List toJavaList() {
+  public final java.util.List<A> toJavaList() {
     return new java.util.ArrayList<>(toStream().toCollection());
   }
 

From bf1d634f012f7014ee8813d1522b3373821f3b91 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 08:49:51 +0100
Subject: [PATCH 048/336] Improve HashMap.Key and HashMap#values

---
 core/src/main/java/fj/data/HashMap.java | 35 ++++++++++---------------
 1 file changed, 14 insertions(+), 21 deletions(-)

diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index 9a145b37..cf112b94 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -8,6 +8,7 @@
 import java.util.Map;
 
 import static fj.P.p;
+import static fj.data.List.iterableList;
 import static fj.data.Option.fromNull;
 
 /**
@@ -17,24 +18,16 @@
  * @see java.util.HashMap
  */
 public final class HashMap<K, V> implements Iterable<K> {
-  private final class Key<K> {
-    private final K k;
-    private final Equal<K> e;
-    private final Hash<K> h;
+  private final class Key {
+    final K k;
 
-    Key(final K k, final Equal<K> e, final Hash<K> h) {
+    Key(final K k) {
       this.k = k;
-      this.e = e;
-      this.h = h;
-    }
-
-    K k() {
-      return k;
     }
 
     @SuppressWarnings("unchecked")
     public boolean equals(final Object o) {
-      return o instanceof Key && e.eq(k, (K) ((Key<?>) o).k());
+      return o instanceof HashMap.Key && e.eq(k, ((Key) o).k);
     }
 
     public int hashCode() {
@@ -51,7 +44,7 @@ public Iterator<K> iterator() {
     return keys().iterator();
   }
 
-  private final java.util.HashMap<Key<K>, V> m;
+  private final java.util.HashMap<Key, V> m;
 
   private final Equal<K> e;
   private final Hash<K> h;
@@ -152,7 +145,7 @@ public int hash(final K k) {
    * @return A potential value for the given key.
    */
   public Option<V> get(final K k) {
-    return fromNull(m.get(new Key<>(k, e, h)));
+    return fromNull(m.get(new Key(k)));
   }
 
   /**
@@ -178,7 +171,7 @@ public void clear() {
    * @return <code>true</code> if this hash map contains the given key, <code>false</code> otherwise.
    */
   public boolean contains(final K k) {
-    return m.containsKey(new Key<>(k, e, h));
+    return m.containsKey(new Key(k));
   }
 
   /**
@@ -189,8 +182,8 @@ public boolean contains(final K k) {
   public List<K> keys() {
     final List.Buffer<K> b = new List.Buffer<>();
 
-    for (final Key<K> k : m.keySet()) {
-      b.snoc(k.k());
+    for (final Key k : m.keySet()) {
+      b.snoc(k.k);
     }
 
     return b.toList();
@@ -202,7 +195,7 @@ public List<K> keys() {
    * @return All values in this hash map.
    */
   public List<V> values() {
-    return keys().map(k -> m.get(new Key<>(k, e, h)));
+    return iterableList(m.values());
   }
 
   /**
@@ -231,7 +224,7 @@ public int size() {
    */
   public void set(final K k, final V v) {
     if (v != null) {
-        m.put(new Key<>(k, e, h), v);
+        m.put(new Key(k), v);
     }
   }
 
@@ -241,7 +234,7 @@ public void set(final K k, final V v) {
    * @param k The key to delete from this hash map.
    */
   public void delete(final K k) {
-    m.remove(new Key<>(k, e, h));
+    m.remove(new Key(k));
   }
 
   /**
@@ -251,7 +244,7 @@ public void delete(final K k) {
    * @return The value that was associated with the given key, if there was one.
    */
   public Option<V> getDelete(final K k) {
-    return fromNull(m.remove(new Key<>(k, e, h)));
+    return fromNull(m.remove(new Key(k)));
   }
 
   public <A, B> HashMap<A, B> map(F<K, A> keyFunction,

From e76812f402df2feece7ca9bc10890ed1e2783abe Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 14:20:05 +0100
Subject: [PATCH 049/336] Precompile regex

---
 core/src/main/java/fj/function/Strings.java | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/function/Strings.java b/core/src/main/java/fj/function/Strings.java
index c64db043..dadbfd22 100644
--- a/core/src/main/java/fj/function/Strings.java
+++ b/core/src/main/java/fj/function/Strings.java
@@ -3,6 +3,9 @@
 import fj.F;
 import fj.data.List;
 import fj.data.Stream;
+
+import java.util.regex.Pattern;
+
 import static fj.Function.curry;
 import static fj.function.Booleans.not;
 import static fj.function.Characters.isWhitespace;
@@ -17,6 +20,8 @@ private Strings() {
     throw new UnsupportedOperationException();
   }
 
+  private static final Pattern lineSeparatorPattern = Pattern.compile("\\r?\\n");
+
   public static final String lineSeparator = System.getProperty("line.separator");
 
     /**
@@ -76,7 +81,7 @@ private Strings() {
   public static final F<String, F<String, Boolean>> matches = curry((s1, s2) -> s2.matches(s1));
 
   public static List<String> lines(String s) {
-    return List.list(s.split("\\r?\\n"));
+    return List.list(lineSeparatorPattern.split(s));
   }
 
   public static F<String, List<String>> lines() {

From 7790a18a976cdb659ca972ebc6892986a981d19b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 14:23:59 +0100
Subject: [PATCH 050/336] Iterate over entrySet of j.u.Map instead of keySet +
 get

---
 core/src/main/java/fj/data/HashMap.java           | 4 ++--
 quickcheck/src/main/java/fj/test/Arbitrary.java   | 4 ++--
 quickcheck/src/main/java/fj/test/Coarbitrary.java | 5 +++--
 quickcheck/src/main/java/fj/test/Shrink.java      | 9 +++++----
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index cf112b94..400cf415 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -63,8 +63,8 @@ public HashMap(final Equal<K> e, final Hash<K> h) {
 
   public HashMap(java.util.Map<K, V> map, final Equal<K> e, final Hash<K> h) {
     this(e, h);
-    for (K key : map.keySet()) {
-      set(key, map.get(key));
+    for (Map.Entry<K, V> entry : map.entrySet()) {
+      set(entry.getKey(), entry.getValue());
     }
   }
 
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 848585aa..c675120c 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -928,8 +928,8 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
       arbitrary(arbHashtable(arbString, arbString).gen.map(ht -> {
         final Properties p = new Properties();
 
-        for (final String k : ht.keySet()) {
-          p.setProperty(k, ht.get(k));
+        for (final Map.Entry<String, String> entry : ht.entrySet()) {
+          p.setProperty(entry.getKey(), entry.getValue());
         }
 
         return p;
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index cd519513..b0f6be6d 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -33,6 +33,7 @@
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Properties;
 import java.util.Stack;
@@ -647,8 +648,8 @@ public static <K, V> Coarbitrary<Hashtable<K, V>> coarbHashtable(final Coarbitra
       public <B> Gen<B> coarbitrary(final Hashtable<K, V> h, final Gen<B> g) {
         List<P2<K, V>> x = nil();
 
-        for (final K k : h.keySet()) {
-          x = x.snoc(p(k, h.get(k)));
+        for (final Map.Entry<K, V> entry : h.entrySet()) {
+          x = x.snoc(p(entry.getKey(), entry.getValue()));
         }
 
         return coarbList(coarbP2(ck, cv)).coarbitrary(x, g);
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 46ca3380..2a2f0061 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -56,6 +56,7 @@
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.PriorityQueue;
 import java.util.Properties;
 import java.util.Stack;
@@ -411,8 +412,8 @@ public static <K, V> Shrink<Hashtable<K, V>> shrinkHashtable(final Shrink<K> sk,
     }, h -> {
       List<P2<K, V>> x = List.nil();
 
-      for (final K k : h.keySet()) {
-        x = x.snoc(p(k, h.get(k)));
+      for (final Map.Entry<K, V> entry : h.entrySet()) {
+        x = x.snoc(p(entry.getKey(), entry.getValue()));
       }
 
       return x;
@@ -478,8 +479,8 @@ public static <A> Shrink<PriorityQueue<A>> shrinkPriorityQueue(final Shrink<A> s
       .map(h -> {
         final Properties p = new Properties();
 
-        for (final String k : h.keySet()) {
-          p.setProperty(k, h.get(k));
+        for (final Map.Entry<String, String> entry : h.entrySet()) {
+          p.setProperty(entry.getKey(), entry.getValue());
         }
 
         return p;

From 4d800f8a2cf45443bace99355839824cd245c6af Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 14:25:52 +0100
Subject: [PATCH 051/336] IOW#getContents and IOW#interact should be static

---
 core/src/main/java/fj/data/IOW.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
index adb0c7af..859c9cdb 100644
--- a/core/src/main/java/fj/data/IOW.java
+++ b/core/src/main/java/fj/data/IOW.java
@@ -35,11 +35,11 @@ public SafeIO<Validation<IOException, A>> safe() {
 
     public <B> IOW<B> append(IO<B> iob) { return lift(IOFunctions.append(io, iob)); }
 
-    public IOW<LazyString> getContents() {
+    public static IOW<LazyString> getContents() {
         return lift(() -> IOFunctions.getContents().run());
     }
 
-    public IOW<Unit> interact(F<LazyString, LazyString> f) {
+    public static IOW<Unit> interact(F<LazyString, LazyString> f) {
         return lift(() -> IOFunctions.interact(f).run());
     }
 }

From 344c9de7c888145bf6a932839bce9df8691ee3e4 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 14:28:30 +0100
Subject: [PATCH 052/336] Presize StringBuilder when possible

---
 core/src/main/java/fj/data/Conversions.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/Conversions.java b/core/src/main/java/fj/data/Conversions.java
index 35cf68be..403ca6d1 100644
--- a/core/src/main/java/fj/data/Conversions.java
+++ b/core/src/main/java/fj/data/Conversions.java
@@ -125,7 +125,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    * A function that converts arrays to strings.
    */
   public static final F<Array<Character>, String> Array_String = cs -> {
-      final StringBuilder sb = new StringBuilder();
+      final StringBuilder sb = new StringBuilder(cs.length());
       cs.foreachDoEffect(sb::append);
       return sb.toString();
   };
@@ -134,7 +134,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    * A function that converts arrays to string buffers.
    */
   public static final F<Array<Character>, StringBuffer> Array_StringBuffer = cs -> {
-      final StringBuffer sb = new StringBuffer();
+      final StringBuffer sb = new StringBuffer(cs.length());
       cs.foreachDoEffect(sb::append);
       return sb;
   };
@@ -143,7 +143,7 @@ public static <A, B> F<P1<A>, F<Array<B>, Either<A, B>>> Array_Either() {
    * A function that converts arrays to string builders.
    */
   public static final F<Array<Character>, StringBuilder> Array_StringBuilder = cs -> {
-      final StringBuilder sb = new StringBuilder();
+      final StringBuilder sb = new StringBuilder(cs.length());
       cs.foreachDoEffect(sb::append);
       return sb;
   };

From 93a003e9cdcb08cadfaed4e04fd5b7aef5e963a6 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 14:36:10 +0100
Subject: [PATCH 053/336] Avoid unnecessary null check in Optional_Option

---
 java8/src/main/java/fj/data/Java8.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
index d893a370..be776822 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/java8/src/main/java/fj/data/Java8.java
@@ -108,7 +108,7 @@ public static <A> Option<A> Optional_Option(final Optional<A> o) {
     }
 
     public static <A> F<Optional<A>, Option<A>> Optional_Option() {
-        return o -> o.isPresent() ? Option.fromNull(o.get()) : Option.none();
+        return o -> o.isPresent() ? Option.some(o.get()) : Option.none();
     }
 
     public static <A> Optional<A> Option_Optional(final Option<A> o) {

From 1e40671d37573a2ebb2aebdc0b5e717a2b6f5357 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:00:30 +0100
Subject: [PATCH 054/336] Array: simpler conversion to jdk collections

---
 core/src/main/java/fj/data/Array.java         | 47 ++++++-------------
 core/src/main/java/fj/data/Java.java          | 34 +++++++-------
 .../src/main/java/fj/test/Arbitrary.java      | 34 +++++++-------
 3 files changed, 49 insertions(+), 66 deletions(-)

diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index 09b56f9a..75dd3c3a 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -13,7 +13,9 @@
 
 import java.util.AbstractCollection;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 
@@ -775,44 +777,25 @@ public Array<P2<A, Integer>> zipIndex() {
    *
    * @return An immutable collection of this array.
    */
-  @SuppressWarnings("unchecked")
   public Collection<A> toCollection() {
-    return new AbstractCollection<A>() {
-      public Iterator<A> iterator() {
-        return new Iterator<A>() {
-          private int i;
-
-          public boolean hasNext() {
-            return i < a.length;
-          }
-
-          public A next() {
-            if (i >= a.length)
-              throw new NoSuchElementException();
-            else {
-              final A aa = (A) a[i];
-              i++;
-              return aa;
-            }
-          }
-
-          public void remove() {
-            throw new UnsupportedOperationException();
-          }
-        };
-      }
+    return asJavaList();
+  }
 
-      public int size() {
-        return a.length;
-      }
-    };
+  /**
+   * Projects an unmodifiable list view of this array.
+   *
+   * @return An unmodifiable list view of this array.
+   */
+  @SuppressWarnings("unchecked")
+  public java.util.List<A> asJavaList() {
+    return Collections.unmodifiableList(Arrays.asList((A[]) a));
   }
 
   /**
-   * Returns a standard java.util.List projection of this array.
+   * Returns a java.util.ArrayList projection of this array.
    */
-  java.util.List<A> toJavaList() {
-    return new ArrayList<>(toCollection());
+  public ArrayList<A> toJavaList() {
+    return new ArrayList<>(asJavaList());
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index b4b6173a..487e9703 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -227,7 +227,7 @@ public static <A> F<List<A>, SynchronousQueue<A>> List_SynchronousQueue(final bo
    * @return A function that converts arrays to array lists.
    */
   public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
-    return as -> new ArrayList<>(as.toCollection());
+    return Array::toJavaList;
   }
 
   /**
@@ -246,7 +246,7 @@ public static <A> F<Array<A>, ArrayList<A>> Array_ArrayList() {
    * @return A function that converts arrays to enum sets.
    */
   public static <A extends Enum<A>> F<Array<A>, EnumSet<A>> Array_EnumSet() {
-    return as -> copyOf(as.toCollection());
+    return as -> copyOf(as.asJavaList());
   }
 
   /**
@@ -255,7 +255,7 @@ public static <A extends Enum<A>> F<Array<A>, EnumSet<A>> Array_EnumSet() {
    * @return A function that converts arrays to hash sets.
    */
   public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
-    return as -> new HashSet<>(as.toCollection());
+    return as -> new HashSet<>(as.asJavaList());
   }
 
   /**
@@ -264,7 +264,7 @@ public static <A> F<Array<A>, HashSet<A>> Array_HashSet() {
    * @return A function that converts arrays to linked hash sets.
    */
   public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
-    return as -> new LinkedHashSet<>(as.toCollection());
+    return as -> new LinkedHashSet<>(as.asJavaList());
   }
 
   /**
@@ -273,7 +273,7 @@ public static <A> F<Array<A>, LinkedHashSet<A>> Array_LinkedHashSet() {
    * @return A function that converts arrays to linked lists.
    */
   public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
-    return as -> new LinkedList<>(as.toCollection());
+    return as -> new LinkedList<>(as.asJavaList());
   }
 
   /**
@@ -282,7 +282,7 @@ public static <A> F<Array<A>, LinkedList<A>> Array_LinkedList() {
    * @return A function that converts arrays to priority queues.
    */
   public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
-    return as -> new PriorityQueue<>(as.toCollection());
+    return as -> new PriorityQueue<>(as.asJavaList());
   }
 
   /**
@@ -293,7 +293,7 @@ public static <A> F<Array<A>, PriorityQueue<A>> Array_PriorityQueue() {
   public static <A> F<Array<A>, Stack<A>> Array_Stack() {
     return as -> {
       final Stack<A> s = new Stack<>();
-      s.addAll(as.toCollection());
+      s.addAll(as.asJavaList());
       return s;
     };
   }
@@ -304,7 +304,7 @@ public static <A> F<Array<A>, Stack<A>> Array_Stack() {
    * @return A function that converts arrays to tree sets.
    */
   public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
-    return as -> new TreeSet<>(as.toCollection());
+    return as -> new TreeSet<>(as.asJavaList());
   }
 
   /**
@@ -313,7 +313,7 @@ public static <A> F<Array<A>, TreeSet<A>> Array_TreeSet() {
    * @return A function that converts arrays to vectors.
    */
   public static <A> F<Array<A>, Vector<A>> Array_Vector() {
-    return as -> new Vector<>(as.toCollection());
+    return as -> new Vector<>(as.asJavaList());
   }
 
   /**
@@ -323,7 +323,7 @@ public static <A> F<Array<A>, Vector<A>> Array_Vector() {
    * @return A function that converts arrays to array blocking queues.
    */
   public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(final boolean fair) {
-    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.toCollection());
+    return as -> new ArrayBlockingQueue<>(as.length(), fair, as.asJavaList());
   }
 
   /**
@@ -332,7 +332,7 @@ public static <A> F<Array<A>, ArrayBlockingQueue<A>> Array_ArrayBlockingQueue(fi
    * @return A function that converts arrays to concurrent linked queues.
    */
   public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQueue() {
-    return as -> new ConcurrentLinkedQueue<>(as.toCollection());
+    return as -> new ConcurrentLinkedQueue<>(as.asJavaList());
   }
 
   /**
@@ -341,7 +341,7 @@ public static <A> F<Array<A>, ConcurrentLinkedQueue<A>> Array_ConcurrentLinkedQu
    * @return A function that converts arrays to copy on write array lists.
    */
   public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayList() {
-    return as -> new CopyOnWriteArrayList<>(as.toCollection());
+    return as -> new CopyOnWriteArrayList<>(as.asJavaList());
   }
 
   /**
@@ -350,7 +350,7 @@ public static <A> F<Array<A>, CopyOnWriteArrayList<A>> Array_CopyOnWriteArrayLis
    * @return A function that converts arrays to copy on write array sets.
    */
   public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet() {
-    return as -> new CopyOnWriteArraySet<>(as.toCollection());
+    return as -> new CopyOnWriteArraySet<>(as.asJavaList());
   }
 
   /**
@@ -359,7 +359,7 @@ public static <A> F<Array<A>, CopyOnWriteArraySet<A>> Array_CopyOnWriteArraySet(
    * @return A function that converts arrays to delay queues.
    */
   public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue() {
-    return as -> new DelayQueue<>(as.toCollection());
+    return as -> new DelayQueue<>(as.asJavaList());
   }
 
   /**
@@ -368,7 +368,7 @@ public static <A extends Delayed> F<Array<A>, DelayQueue<A>> Array_DelayQueue()
    * @return A function that converts arrays to linked blocking queues.
    */
   public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue() {
-    return as -> new LinkedBlockingQueue<>(as.toCollection());
+    return as -> new LinkedBlockingQueue<>(as.asJavaList());
   }
 
   /**
@@ -377,7 +377,7 @@ public static <A> F<Array<A>, LinkedBlockingQueue<A>> Array_LinkedBlockingQueue(
    * @return A function that converts arrays to priority blocking queues.
    */
   public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQueue() {
-    return as -> new PriorityBlockingQueue<>(as.toCollection());
+    return as -> new PriorityBlockingQueue<>(as.asJavaList());
   }
 
   /**
@@ -389,7 +389,7 @@ public static <A> F<Array<A>, PriorityBlockingQueue<A>> Array_PriorityBlockingQu
   public static <A> F<Array<A>, SynchronousQueue<A>> Array_SynchronousQueue(final boolean fair) {
     return as -> {
       final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
-      q.addAll(as.toCollection());
+      q.addAll(as.asJavaList());
       return q;
     };
   }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index c675120c..20e6e2f0 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -753,7 +753,7 @@ public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
    * @return An arbitrary implementation for array lists.
    */
   public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new ArrayList<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(Array::toJavaList));
   }
 
   /**
@@ -810,7 +810,7 @@ public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final A
    * @return An arbitrary implementation for enum sets.
    */
   public static <A extends Enum<A>> Arbitrary<EnumSet<A>> arbEnumSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.asJavaList())));
   }
 
   /**
@@ -842,7 +842,7 @@ public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak,
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.asJavaList())));
   }
 
   /**
@@ -898,7 +898,7 @@ public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbit
    * @return An arbitrary implementation for hash sets.
    */
   public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.asJavaList())));
   }
 
   /**
@@ -908,7 +908,7 @@ public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A
    * @return An arbitrary implementation for linked lists.
    */
   public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.asJavaList())));
   }
 
   /**
@@ -918,7 +918,7 @@ public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa)
    * @return An arbitrary implementation for priority queues.
    */
   public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.asJavaList())));
   }
 
   /**
@@ -944,7 +944,7 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
   public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.map(a -> {
       final Stack<A> s = new Stack<>();
-      s.addAll(a.toCollection());
+      s.addAll(a.asJavaList());
       return s;
     }));
   }
@@ -1005,7 +1005,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
    * @return An arbitrary implementation for tree sets.
    */
   public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.asJavaList())));
   }
 
   /**
@@ -1016,7 +1016,7 @@ public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
    */
   @SuppressWarnings("UseOfObsoleteCollectionType")
   public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.asJavaList())));
   }
 
   /**
@@ -1046,7 +1046,7 @@ public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary
   public static <A> Arbitrary<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.bind(arbInteger.gen, arbBoolean.gen,
         a -> capacity -> fair -> new ArrayBlockingQueue<A>(a.length() + abs(capacity),
-                                         fair, a.toCollection())));
+                                         fair, a.asJavaList())));
   }
 
   /**
@@ -1071,7 +1071,7 @@ public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(fin
    * @return An arbitrary implementation for concurrent linked queues.
    */
   public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.asJavaList())));
   }
 
   /**
@@ -1082,7 +1082,7 @@ public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(f
    * @return An arbitrary implementation for copy-on-write array lists.
    */
   public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.asJavaList())));
   }
 
   /**
@@ -1093,7 +1093,7 @@ public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(fin
    * @return An arbitrary implementation for copy-on-write array sets.
    */
   public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.asJavaList())));
   }
 
   /**
@@ -1103,7 +1103,7 @@ public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final
    * @return An arbitrary implementation for delay queues.
    */
   public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.asJavaList())));
   }
 
   /**
@@ -1114,7 +1114,7 @@ public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final A
    * @return An arbitrary implementation for linked blocking queues.
    */
   public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.asJavaList())));
   }
 
   /**
@@ -1125,7 +1125,7 @@ public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final
    * @return An arbitrary implementation for priority blocking queues.
    */
   public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.toCollection())));
+    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.asJavaList())));
   }
 
   /**
@@ -1138,7 +1138,7 @@ public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(f
   public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbitrary<A> aa) {
     return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, a -> fair -> {
       final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
-      q.addAll(a.toCollection());
+      q.addAll(a.asJavaList());
       return q;
     }));
   }

From cdd8fbe647a06d54cd6b708ef2d4bd90b3daffce Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:05:11 +0100
Subject: [PATCH 055/336] Avoid unecessary array type cast.

---
 .../src/main/java/fj/test/Arbitrary.java      |  2 +-
 .../src/main/java/fj/test/Coarbitrary.java    | 29 ++++++++++---------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 20e6e2f0..a776e15b 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -716,7 +716,7 @@ public static <A> Arbitrary<Array<A>> arbArray(final Arbitrary<A> aa) {
    */
   @SuppressWarnings("unchecked")
   public static <A> Arbitrary<Seq<A>> arbSeq(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(array -> Seq.seq((A[]) array.array())));
+    return arbitrary(arbArray(aa).gen.map(Seq::iterableSeq));
   }
 
 	public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa) {
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index b0f6be6d..d158a90f 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -8,6 +8,7 @@
 import fj.data.*;
 
 import static fj.data.Array.array;
+import static fj.data.Array.iterableArray;
 import static fj.data.List.fromString;
 import static fj.data.List.nil;
 
@@ -525,7 +526,7 @@ public static <A> Coarbitrary<ArrayList<A>> coarbArrayList(final Coarbitrary<A>
     return new Coarbitrary<ArrayList<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ArrayList<A> as, final Gen<B> g) {
-        return coarbArray(ca).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(ca).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -630,7 +631,7 @@ public static <A> Coarbitrary<HashSet<A>> coarbHashSet(final Coarbitrary<A> c) {
     return new Coarbitrary<HashSet<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final HashSet<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -716,7 +717,7 @@ public static <A> Coarbitrary<LinkedList<A>> coarbLinkedList(final Coarbitrary<A
     return new Coarbitrary<LinkedList<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedList<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -731,7 +732,7 @@ public static <A> Coarbitrary<PriorityQueue<A>> coarbPriorityQueue(final Coarbit
     return new Coarbitrary<PriorityQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final PriorityQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -762,7 +763,7 @@ public static <A> Coarbitrary<Stack<A>> coarbStack(final Coarbitrary<A> c) {
     return new Coarbitrary<Stack<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final Stack<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -808,7 +809,7 @@ public static <A> Coarbitrary<Vector<A>> coarbVector(final Coarbitrary<A> c) {
     return new Coarbitrary<Vector<A>>() {
       @SuppressWarnings({"unchecked", "UseOfObsoleteCollectionType"})
       public <B> Gen<B> coarbitrary(final Vector<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -844,7 +845,7 @@ public static <A> Coarbitrary<ArrayBlockingQueue<A>> coarbArrayBlockingQueue(fin
     return new Coarbitrary<ArrayBlockingQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ArrayBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -876,7 +877,7 @@ public static <A> Coarbitrary<ConcurrentLinkedQueue<A>> coarbConcurrentLinkedQue
     return new Coarbitrary<ConcurrentLinkedQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final ConcurrentLinkedQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -891,7 +892,7 @@ public static <A> Coarbitrary<CopyOnWriteArrayList<A>> coarbCopyOnWriteArrayList
     return new Coarbitrary<CopyOnWriteArrayList<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final CopyOnWriteArrayList<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -906,7 +907,7 @@ public static <A> Coarbitrary<CopyOnWriteArraySet<A>> coarbCopyOnWriteArraySet(f
     return new Coarbitrary<CopyOnWriteArraySet<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final CopyOnWriteArraySet<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -921,7 +922,7 @@ public static <A extends Delayed> Coarbitrary<DelayQueue<A>> coarbDelayQueue(fin
     return new Coarbitrary<DelayQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final DelayQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -936,7 +937,7 @@ public static <A> Coarbitrary<LinkedBlockingQueue<A>> coarbLinkedBlockingQueue(f
     return new Coarbitrary<LinkedBlockingQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final LinkedBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -951,7 +952,7 @@ public static <A> Coarbitrary<PriorityBlockingQueue<A>> coarbPriorityBlockingQue
     return new Coarbitrary<PriorityBlockingQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final PriorityBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }
@@ -966,7 +967,7 @@ public static <A> Coarbitrary<SynchronousQueue<A>> coarbSynchronousQueue(final C
     return new Coarbitrary<SynchronousQueue<A>>() {
       @SuppressWarnings("unchecked")
       public <B> Gen<B> coarbitrary(final SynchronousQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(array(as.toArray((A[]) new Object[as.size()])), g);
+        return coarbArray(c).coarbitrary(iterableArray(as), g);
       }
     };
   }

From dd14dd4f9f0b1de69913d6e86736ffe47625fa27 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:06:27 +0100
Subject: [PATCH 056/336] make implicit throw explicit for readability

---
 quickcheck/src/main/java/fj/test/Arbitrary.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index a776e15b..e2a00b29 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -981,7 +981,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
     public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<K> ak, Arbitrary<V> av, Arbitrary<Integer> ai) {
         Gen<List<P2<K, V>>> gl2 = ai.gen.bind(i -> {
             if (i < 0) {
-                Bottom.error("Undefined: arbitrary natural is negative (" + i + ")");
+                throw Bottom.error("Undefined: arbitrary natural is negative (" + i + ")");
             }
             return Gen.sequenceN(Math.max(i, 0), arbP2(ak, av).gen);
         });
@@ -993,7 +993,7 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
      */
     public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<K> ak, Arbitrary<V> av, int maxSize) {
         if (maxSize < 0) {
-            Bottom.error("Undefined: arbitrary natural is negative (" + maxSize + ")");
+          throw Bottom.error("Undefined: arbitrary natural is negative (" + maxSize + ")");
         }
         return arbTreeMap(ord, ak, av, arbitrary(choose(0, maxSize)));
     }

From d33454285e734a8c4654e06d7c8e4771e440bbf2 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:09:29 +0100
Subject: [PATCH 057/336] use Strings#lineSeparator instead of
 System.getProperty("line.separator")

---
 quickcheck/src/main/java/fj/test/CheckResult.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/CheckResult.java b/quickcheck/src/main/java/fj/test/CheckResult.java
index 718daf03..c9c0a2fe 100644
--- a/quickcheck/src/main/java/fj/test/CheckResult.java
+++ b/quickcheck/src/main/java/fj/test/CheckResult.java
@@ -5,6 +5,8 @@
 import fj.Show;
 import fj.data.List;
 import fj.data.Option;
+import fj.function.Strings;
+
 import static fj.data.Option.some;
 import static fj.Show.listShow;
 import static fj.Show.showS;
@@ -252,12 +254,12 @@ else if (r.isPropException()) {
           final StringWriter sw = new StringWriter();
           final PrintWriter pw = new PrintWriter(sw);
           r.exception().some().printStackTrace(pw);
-          return "Exception on property evaluation with " + arguments(r) + System.getProperty("line.separator") + sw;
+          return "Exception on property evaluation with " + arguments(r) + Strings.lineSeparator + sw;
         } else if (r.isGenException()) {
           final StringWriter sw = new StringWriter();
           final PrintWriter pw = new PrintWriter(sw);
           r.exception().some().printStackTrace(pw);
-          return "Exception on argument generation " + System.getProperty("line.separator") + sw;
+          return "Exception on argument generation " + Strings.lineSeparator + sw;
         } else
           throw decons(r.getClass());
       }

From 99fe9fdb93fa0bab9c1adc1930b5284a4570e423 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:38:10 +0100
Subject: [PATCH 058/336] Make methods that are not meant to be overriden
 final.

---
 core/src/main/java/fj/F1W.java                | 138 +++++------
 core/src/main/java/fj/F2W.java                |  54 ++---
 core/src/main/java/fj/LcgRng.java             |   6 +-
 core/src/main/java/fj/Ord.java                |   2 +-
 core/src/main/java/fj/P1.java                 |  48 ++--
 core/src/main/java/fj/P2.java                 |   6 +-
 core/src/main/java/fj/P3.java                 |   6 +-
 core/src/main/java/fj/P4.java                 |   6 +-
 core/src/main/java/fj/P5.java                 |   6 +-
 core/src/main/java/fj/P6.java                 |   6 +-
 core/src/main/java/fj/P7.java                 |   6 +-
 core/src/main/java/fj/P8.java                 |   6 +-
 core/src/main/java/fj/Rng.java                |   4 +-
 core/src/main/java/fj/control/Trampoline.java |   6 +-
 core/src/main/java/fj/data/Either.java        |  22 +-
 core/src/main/java/fj/data/List.java          |  38 +--
 core/src/main/java/fj/data/Option.java        |  28 +--
 core/src/main/java/fj/data/Reader.java        |  12 +-
 core/src/main/java/fj/data/Set.java           |  10 +-
 core/src/main/java/fj/data/Stream.java        |  10 +-
 core/src/main/java/fj/data/Validation.java    | 218 +++++++++---------
 .../main/java/fj/data/fingertrees/Digit.java  |   4 +-
 .../java/fj/data/fingertrees/FingerTree.java  |  10 +-
 .../main/java/fj/data/fingertrees/Node.java   |   2 +-
 core/src/main/java/fj/data/optic/PIso.java    |   2 +-
 demo/src/main/java/fj/demo/IODemo.java        |   8 +-
 .../fj/demo/StateDemo_VendingMachine.java     |   8 +-
 .../main/java/fj/demo/concurrent/Ping.java    |   4 +-
 .../java/fj/demo/concurrent/PingPong.java     |   2 +-
 .../main/java/fj/demo/concurrent/Pong.java    |   2 +-
 .../main/java/fj/demo/optic/LensPerson.java   |   8 +-
 .../fj/test/runner/PropertyTestRunner.java    |   6 +-
 32 files changed, 348 insertions(+), 346 deletions(-)

diff --git a/core/src/main/java/fj/F1W.java b/core/src/main/java/fj/F1W.java
index 19a978dc..611c9e01 100644
--- a/core/src/main/java/fj/F1W.java
+++ b/core/src/main/java/fj/F1W.java
@@ -22,7 +22,7 @@ public abstract class F1W<A, B> implements F<A, B> {
      * @param g A function to compose with this one.
      * @return The composed function such that this function is applied last.
      */
-    public <C> F1W<C, B> o(final F<C, A> g) {
+    public final <C> F1W<C, B> o(final F<C, A> g) {
         return lift(F1Functions.o(this, g));
     }
 
@@ -31,7 +31,7 @@ public <C> F1W<C, B> o(final F<C, A> g) {
      *
      * @return A function that composes this function with another.
      */
-    public <C> F1W<F<C, A>, F<C, B>> o() {
+    public final <C> F1W<F<C, A>, F<C, B>> o() {
         return lift(F1Functions.o(this));
     }
 
@@ -42,7 +42,7 @@ public <C> F1W<F<C, A>, F<C, B>> o() {
      * @return The composed function such that this function is applied first.
      */
     @SuppressWarnings("unchecked")
-    public <C> F1W<A, C> andThen(final F<B, C> g) {
+    public final <C> F1W<A, C> andThen(final F<B, C> g) {
         return lift(F1Functions.andThen(this, g));
     }
 
@@ -51,7 +51,7 @@ public <C> F1W<A, C> andThen(final F<B, C> g) {
      *
      * @return A function that invokes this function and then a given function on the result.
      */
-    public <C> F1W<F<B, C>, F<A, C>> andThen() {
+    public final <C> F1W<F<B, C>, F<A, C>> andThen() {
         return lift( F1Functions.andThen(this));
     }
 
@@ -61,7 +61,7 @@ public <C> F1W<F<B, C>, F<A, C>> andThen() {
      * @param g A function that takes the return value of this function as an argument, yielding a new function.
      * @return A function that invokes this function on its argument and then the given function on the result.
      */
-    public <C> F1W<A, C> bind(final F<B, F<A, C>> g) {
+    public final <C> F1W<A, C> bind(final F<B, F<A, C>> g) {
         return lift(F1Functions.bind(this, g));
     }
 
@@ -71,7 +71,7 @@ public <C> F1W<A, C> bind(final F<B, F<A, C>> g) {
      *
      * @return A function that binds another function across this function.
      */
-    public <C> F1W<F<B, F<A, C>>, F<A, C>> bind() {
+    public final <C> F1W<F<B, F<A, C>>, F<A, C>> bind() {
         return lift(F1Functions.bind(this));
     }
 
@@ -83,7 +83,7 @@ public <C> F1W<F<B, F<A, C>>, F<A, C>> bind() {
      * @return A new function that invokes the given function on its argument, yielding a new function that is then
      *         applied to the result of applying this function to the argument.
      */
-    public <C> F1W<A, C> apply(final F<A, F<B, C>> g) {
+    public final <C> F1W<A, C> apply(final F<A, F<B, C>> g) {
         return lift(F1Functions.apply(this, g));
     }
 
@@ -93,7 +93,7 @@ public <C> F1W<A, C> apply(final F<A, F<B, C>> g) {
      *
      * @return A function that applies a given function within the environment of this function.
      */
-    public <C> F1W<F<A, F<B, C>>, F<A, C>> apply() {
+    public final <C> F1W<F<A, F<B, C>>, F<A, C>> apply() {
         return lift(F1Functions.apply(this));
     }
 
@@ -103,7 +103,7 @@ public <C> F1W<F<A, F<B, C>>, F<A, C>> apply() {
      * @param g The function over whose arguments to apply this function.
      * @return A new function that invokes this function on its arguments before invoking the given function.
      */
-    public <C> F1W<A, F<A, C>> on(final F<B, F<B, C>> g) {
+    public final <C> F1W<A, F<A, C>> on(final F<B, F<B, C>> g) {
         return lift(F1Functions.on(this, g));
     }
 
@@ -113,7 +113,7 @@ public <C> F1W<A, F<A, C>> on(final F<B, F<B, C>> g) {
      *
      * @return A function that applies this function over the arguments of another function.
      */
-    public <C> F1W<F<B, F<B, C>>, F<A, F<A, C>>> on() {
+    public final <C> F1W<F<B, F<B, C>>, F<A, F<A, C>>> on() {
         return lift(F1Functions.on(this));
     }
 
@@ -122,7 +122,7 @@ public <C> F1W<F<B, F<B, C>>, F<A, F<A, C>>> on() {
      *
      * @return This function promoted to return its result in a product-1.
      */
-    public F1W<A, P1<B>> lazy() {
+    public final F1W<A, P1<B>> lazy() {
         return lift(F1Functions.lazy(this));
     }
 
@@ -133,7 +133,7 @@ public F1W<A, P1<B>> lazy() {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument to return a lazy value.
      */
-    public P1<B> lazy(final A a) {
+    public final P1<B> lazy(final A a) {
         return F1Functions.f(this, a);
     }
 
@@ -142,7 +142,7 @@ public P1<B> lazy(final A a) {
      *
      * @return This function promoted to map over a product-1.
      */
-    public F1W<P1<A>, P1<B>> mapP1() {
+    public final F1W<P1<A>, P1<B>> mapP1() {
         return lift(F1Functions.mapP1(this));
     }
 
@@ -151,7 +151,7 @@ public F1W<P1<A>, P1<B>> mapP1() {
      *
      * @return This function promoted to return its result in an Option.
      */
-    public F1W<A, Option<B>> optionK() {
+    public final F1W<A, Option<B>> optionK() {
         return lift(F1Functions.optionK(this));
     }
 
@@ -161,7 +161,7 @@ public F1W<A, Option<B>> optionK() {
      *
      * @return This function promoted to map over an optional value.
      */
-    public F1W<Option<A>, Option<B>> mapOption() {
+    public final F1W<Option<A>, Option<B>> mapOption() {
         return lift(F1Functions.mapOption(this));
     }
 
@@ -170,7 +170,7 @@ public F1W<Option<A>, Option<B>> mapOption() {
      *
      * @return This function promoted to return its result in a List.
      */
-    public F1W<A, List<B>> listK() {
+    public final F1W<A, List<B>> listK() {
         return lift( F1Functions.listK(this));
     }
 
@@ -179,7 +179,7 @@ public F1W<A, List<B>> listK() {
      *
      * @return This function promoted to map over a List.
      */
-    public F1W<List<A>, List<B>> mapList() {
+    public final F1W<List<A>, List<B>> mapList() {
         return lift(F1Functions.mapList(this));
     }
 
@@ -188,7 +188,7 @@ public F1W<List<A>, List<B>> mapList() {
      *
      * @return This function promoted to return its result in a Stream.
      */
-    public F1W<A, Stream<B>> streamK() {
+    public final F1W<A, Stream<B>> streamK() {
         return lift(F1Functions.streamK(this));
     }
 
@@ -197,7 +197,7 @@ public F1W<A, Stream<B>> streamK() {
      *
      * @return This function promoted to map over a Stream.
      */
-    public F1W<Stream<A>, Stream<B>> mapStream() {
+    public final F1W<Stream<A>, Stream<B>> mapStream() {
         return lift(F1Functions.mapStream(this));
     }
 
@@ -206,7 +206,7 @@ public F1W<Stream<A>, Stream<B>> mapStream() {
      *
      * @return This function promoted to return its result in a Array.
      */
-    public F1W<A, Array<B>> arrayK() {
+    public final F1W<A, Array<B>> arrayK() {
         return lift(F1Functions.arrayK(this));
 
     }
@@ -216,7 +216,7 @@ public F1W<A, Array<B>> arrayK() {
      *
      * @return This function promoted to map over a Array.
      */
-    public F1W<Array<A>, Array<B>> mapArray() {
+    public final F1W<Array<A>, Array<B>> mapArray() {
         return lift(F1Functions.mapArray(this));
     }
 
@@ -225,7 +225,7 @@ public F1W<Array<A>, Array<B>> mapArray() {
      *
      * @return A function that contramaps over a given actor.
      */
-    public F1W<Actor<B>, Actor<A>> contramapActor() {
+    public final F1W<Actor<B>, Actor<A>> contramapActor() {
         return lift(F1Functions.contramapActor(this));
     }
 
@@ -235,7 +235,7 @@ public F1W<Actor<B>, Actor<A>> contramapActor() {
      * @param s A parallel strategy for concurrent execution.
      * @return A concurrent function that returns a Promise of a value.
      */
-    public F1W<A, Promise<B>> promiseK(final Strategy<Unit> s) {
+    public final F1W<A, Promise<B>> promiseK(final Strategy<Unit> s) {
         return lift(F1Functions.promiseK(this, s));
     }
 
@@ -244,7 +244,7 @@ public F1W<A, Promise<B>> promiseK(final Strategy<Unit> s) {
      *
      * @return This function promoted to map over Promises.
      */
-    public F1W<Promise<A>, Promise<B>> mapPromise() {
+    public final F1W<Promise<A>, Promise<B>> mapPromise() {
         return lift(F1Functions.mapPromise(this));
     }
 
@@ -255,7 +255,7 @@ public F1W<Promise<A>, Promise<B>> mapPromise() {
      * @return This function promoted to return its result on the left side of an Either.
      */
     @SuppressWarnings("unchecked")
-    public <C> F1W<A, Either<B, C>> eitherLeftK() {
+    public final <C> F1W<A, Either<B, C>> eitherLeftK() {
         return lift(F1Functions.eitherLeftK(this));
     }
 
@@ -266,7 +266,7 @@ public <C> F1W<A, Either<B, C>> eitherLeftK() {
      * @return This function promoted to return its result on the right side of an Either.
      */
     @SuppressWarnings("unchecked")
-    public <C> F1W<A, Either<C, B>> eitherRightK() {
+    public final <C> F1W<A, Either<C, B>> eitherRightK() {
         return lift(F1Functions.eitherRightK(this));
     }
 
@@ -276,7 +276,7 @@ public <C> F1W<A, Either<C, B>> eitherRightK() {
      * @return This function promoted to map over the left side of an Either.
      */
     @SuppressWarnings("unchecked")
-    public <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
+    public final <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
         return lift(F1Functions.mapLeft(this));
     }
 
@@ -286,7 +286,7 @@ public <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
      * @return This function promoted to map over the right side of an Either.
      */
     @SuppressWarnings("unchecked")
-    public <X> F1W<Either<X, A>, Either<X, B>> mapRight() {
+    public final <X> F1W<Either<X, A>, Either<X, B>> mapRight() {
         return lift(F1Functions.mapRight(this));
     }
 
@@ -295,7 +295,7 @@ public <X> F1W<Either<X, A>, Either<X, B>> mapRight() {
      *
      * @return a function that returns the left side of a given Either, or this function applied to the right side.
      */
-    public F1W<Either<B, A>, B> onLeft() {
+    public final F1W<Either<B, A>, B> onLeft() {
         return lift(F1Functions.onLeft(this));
     }
 
@@ -304,7 +304,7 @@ public F1W<Either<B, A>, B> onLeft() {
      *
      * @return a function that returns the right side of a given Either, or this function applied to the left side.
      */
-    public F1W<Either<A, B>, B> onRight() {
+    public final F1W<Either<A, B>, B> onRight() {
         return lift(F1Functions.onRight(this));
     }
 
@@ -314,7 +314,7 @@ public F1W<Either<A, B>, B> onRight() {
      * @return This function promoted to return its value in an Iterable.
      */
     @SuppressWarnings("unchecked")
-    public F1W<A, IterableW<B>> iterableK() {
+    public final F1W<A, IterableW<B>> iterableK() {
         return lift( F1Functions.iterableK(this));
     }
 
@@ -324,7 +324,7 @@ public F1W<A, IterableW<B>> iterableK() {
      * @return This function promoted to map over Iterables.
      */
     @SuppressWarnings("unchecked")
-    public F1W<Iterable<A>, IterableW<B>> mapIterable() {
+    public final F1W<Iterable<A>, IterableW<B>> mapIterable() {
         return lift( F1Functions.mapIterable(this));
     }
 
@@ -334,7 +334,7 @@ public F1W<Iterable<A>, IterableW<B>> mapIterable() {
      * @return This function promoted to return its value in a NonEmptyList.
      */
     @SuppressWarnings("unchecked")
-    public F1W<A, NonEmptyList<B>> nelK() {
+    public final F1W<A, NonEmptyList<B>> nelK() {
         return lift(F1Functions.nelK(this));
     }
 
@@ -343,7 +343,7 @@ public F1W<A, NonEmptyList<B>> nelK() {
      *
      * @return This function promoted to map over a NonEmptyList.
      */
-    public F1W<NonEmptyList<A>, NonEmptyList<B>> mapNel() {
+    public final F1W<NonEmptyList<A>, NonEmptyList<B>> mapNel() {
         return lift(F1Functions.mapNel(this));
     }
 
@@ -353,7 +353,7 @@ public F1W<NonEmptyList<A>, NonEmptyList<B>> mapNel() {
      * @param o An order for the set.
      * @return This function promoted to return its value in a Set.
      */
-    public F1W<A, Set<B>> setK(final Ord<B> o) {
+    public final F1W<A, Set<B>> setK(final Ord<B> o) {
         return lift(F1Functions.setK(this, o));
     }
 
@@ -363,7 +363,7 @@ public F1W<A, Set<B>> setK(final Ord<B> o) {
      * @param o An order for the resulting set.
      * @return This function promoted to map over a Set.
      */
-    public F1W<Set<A>, Set<B>> mapSet(final Ord<B> o) {
+    public final F1W<Set<A>, Set<B>> mapSet(final Ord<B> o) {
         return lift(F1Functions.mapSet(this, o));
     }
 
@@ -372,7 +372,7 @@ public F1W<Set<A>, Set<B>> mapSet(final Ord<B> o) {
      *
      * @return This function promoted to return its value in a Tree.
      */
-    public F1W<A, Tree<B>> treeK() {
+    public final F1W<A, Tree<B>> treeK() {
         return lift(F1Functions.treeK(this));
     }
 
@@ -382,7 +382,7 @@ public F1W<A, Tree<B>> treeK() {
      * @return This function promoted to map over a Tree.
      */
     @SuppressWarnings("unchecked")
-    public F1W<Tree<A>, Tree<B>> mapTree() {
+    public final F1W<Tree<A>, Tree<B>> mapTree() {
         return lift(F1Functions.mapTree(this));
     }
 
@@ -392,7 +392,7 @@ public F1W<Tree<A>, Tree<B>> mapTree() {
      * @param m The monoid with which to fold the mapped tree.
      * @return a function that maps this function over a tree and folds it with the given monoid.
      */
-    public F1W<Tree<A>, B> foldMapTree(final Monoid<B> m) {
+    public final F1W<Tree<A>, B> foldMapTree(final Monoid<B> m) {
         return lift(F1Functions.foldMapTree(this, m));
     }
 
@@ -401,7 +401,7 @@ public F1W<Tree<A>, B> foldMapTree(final Monoid<B> m) {
      *
      * @return This function promoted to return its value in a TreeZipper.
      */
-    public F1W<A, TreeZipper<B>> treeZipperK() {
+    public final F1W<A, TreeZipper<B>> treeZipperK() {
         return lift(F1Functions.treeZipperK(this));
     }
 
@@ -410,7 +410,7 @@ public F1W<A, TreeZipper<B>> treeZipperK() {
      *
      * @return This function promoted to map over a TreeZipper.
      */
-    public F1W<TreeZipper<A>, TreeZipper<B>> mapTreeZipper() {
+    public final F1W<TreeZipper<A>, TreeZipper<B>> mapTreeZipper() {
         return lift(F1Functions.mapTreeZipper(this));
     }
 
@@ -420,7 +420,7 @@ public F1W<TreeZipper<A>, TreeZipper<B>> mapTreeZipper() {
      *
      * @return This function promoted to return its result on the failure side of a Validation.
      */
-    public <C> F1W<A, Validation<B, C>> failK() {
+    public final <C> F1W<A, Validation<B, C>> failK() {
         return lift(F1Functions.failK(this));
     }
 
@@ -430,7 +430,7 @@ public <C> F1W<A, Validation<B, C>> failK() {
      *
      * @return This function promoted to return its result on the success side of an Validation.
      */
-    public <C> F1W<A, Validation<C, B>> successK() {
+    public final <C> F1W<A, Validation<C, B>> successK() {
         return lift( F1Functions.successK(this));
     }
 
@@ -439,7 +439,7 @@ public <C> F1W<A, Validation<C, B>> successK() {
      *
      * @return This function promoted to map over the failure side of a Validation.
      */
-    public <X> F1W<Validation<A, X>, Validation<B, X>> mapFail() {
+    public final <X> F1W<Validation<A, X>, Validation<B, X>> mapFail() {
         return lift(F1Functions.mapFail(this));
     }
 
@@ -448,7 +448,7 @@ public <X> F1W<Validation<A, X>, Validation<B, X>> mapFail() {
      *
      * @return This function promoted to map over the success side of a Validation.
      */
-    public <X> F1W<Validation<X, A>, Validation<X, B>> mapSuccess() {
+    public final <X> F1W<Validation<X, A>, Validation<X, B>> mapSuccess() {
         return lift(F1Functions.mapSuccess(this));
     }
 
@@ -459,7 +459,7 @@ public <X> F1W<Validation<X, A>, Validation<X, B>> mapSuccess() {
      * @return a function that returns the failure side of a given Validation,
      *         or this function applied to the success side.
      */
-    public F1W<Validation<B, A>, B> onFail() {
+    public final F1W<Validation<B, A>, B> onFail() {
         return lift(F1Functions.onFail(this));
     }
 
@@ -470,7 +470,7 @@ public F1W<Validation<B, A>, B> onFail() {
      * @return a function that returns the success side of a given Validation,
      *         or this function applied to the failure side.
      */
-    public F1W<Validation<A, B>, B> onSuccess() {
+    public final F1W<Validation<A, B>, B> onSuccess() {
         return lift(F1Functions.onSuccess(this));
     }
 
@@ -479,7 +479,7 @@ public F1W<Validation<A, B>, B> onSuccess() {
      *
      * @return This function promoted to return its value in a Zipper.
      */
-    public F1W<A, Zipper<B>> zipperK() {
+    public final F1W<A, Zipper<B>> zipperK() {
         return lift(F1Functions.zipperK(this));
     }
 
@@ -488,7 +488,7 @@ public F1W<A, Zipper<B>> zipperK() {
      *
      * @return This function promoted to map over a Zipper.
      */
-    public F1W<Zipper<A>, Zipper<B>> mapZipper() {
+    public final F1W<Zipper<A>, Zipper<B>> mapZipper() {
         return lift(F1Functions.mapZipper(this));
     }
 
@@ -497,7 +497,7 @@ public F1W<Zipper<A>, Zipper<B>> mapZipper() {
      *
      * @return This function promoted to map over an Equal as a contravariant functor.
      */
-    public F1W<Equal<B>, Equal<A>> contramapEqual() {
+    public final F1W<Equal<B>, Equal<A>> contramapEqual() {
         return lift(F1Functions.contramapEqual(this));
     }
 
@@ -506,7 +506,7 @@ public F1W<Equal<B>, Equal<A>> contramapEqual() {
      *
      * @return This function promoted to map over a Hash as a contravariant functor.
      */
-    public F1W<Hash<B>, Hash<A>> contramapHash() {
+    public final F1W<Hash<B>, Hash<A>> contramapHash() {
         return lift(F1Functions.contramapHash(this));
     }
 
@@ -515,7 +515,7 @@ public F1W<Hash<B>, Hash<A>> contramapHash() {
      *
      * @return This function promoted to map over a Show as a contravariant functor.
      */
-    public F1W<Show<B>, Show<A>> contramapShow() {
+    public final F1W<Show<B>, Show<A>> contramapShow() {
         return lift(F1Functions.contramapShow(this));
     }
 
@@ -524,7 +524,7 @@ public F1W<Show<B>, Show<A>> contramapShow() {
      *
      * @return This function promoted to map over the first element of a pair.
      */
-    public <C> F1W<P2<A, C>, P2<B, C>> mapFst() {
+    public final <C> F1W<P2<A, C>, P2<B, C>> mapFst() {
         return lift(F1Functions.mapFst(this));
     }
 
@@ -533,7 +533,7 @@ public <C> F1W<P2<A, C>, P2<B, C>> mapFst() {
      *
      * @return This function promoted to map over the second element of a pair.
      */
-    public <C> F1W<P2<C, A>, P2<C, B>> mapSnd() {
+    public final <C> F1W<P2<C, A>, P2<C, B>> mapSnd() {
         return lift(F1Functions.mapSnd(this));
     }
 
@@ -542,7 +542,7 @@ public <C> F1W<P2<C, A>, P2<C, B>> mapSnd() {
      *
      * @return This function promoted to map over both elements of a pair.
      */
-    public F1W<P2<A, A>, P2<B, B>> mapBoth() {
+    public final F1W<P2<A, A>, P2<B, B>> mapBoth() {
         return lift(F1Functions.mapBoth(this));
     }
 
@@ -552,7 +552,7 @@ public F1W<P2<A, A>, P2<B, B>> mapBoth() {
      * @param as A SynchronousQueue to map this function over.
      * @return A new SynchronousQueue with this function applied to each element.
      */
-    public SynchronousQueue<B> mapJ(final SynchronousQueue<A> as) {
+    public final SynchronousQueue<B> mapJ(final SynchronousQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -563,7 +563,7 @@ public SynchronousQueue<B> mapJ(final SynchronousQueue<A> as) {
      * @param as A PriorityBlockingQueue to map this function over.
      * @return A new PriorityBlockingQueue with this function applied to each element.
      */
-    public PriorityBlockingQueue<B> mapJ(final PriorityBlockingQueue<A> as) {
+    public final PriorityBlockingQueue<B> mapJ(final PriorityBlockingQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -573,7 +573,7 @@ public PriorityBlockingQueue<B> mapJ(final PriorityBlockingQueue<A> as) {
      * @param as A LinkedBlockingQueue to map this function over.
      * @return A new LinkedBlockingQueue with this function applied to each element.
      */
-    public LinkedBlockingQueue<B> mapJ(final LinkedBlockingQueue<A> as) {
+    public final LinkedBlockingQueue<B> mapJ(final LinkedBlockingQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -583,7 +583,7 @@ public LinkedBlockingQueue<B> mapJ(final LinkedBlockingQueue<A> as) {
      * @param as A CopyOnWriteArraySet to map this function over.
      * @return A new CopyOnWriteArraySet with this function applied to each element.
      */
-    public CopyOnWriteArraySet<B> mapJ(final CopyOnWriteArraySet<A> as) {
+    public final CopyOnWriteArraySet<B> mapJ(final CopyOnWriteArraySet<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -593,7 +593,7 @@ public CopyOnWriteArraySet<B> mapJ(final CopyOnWriteArraySet<A> as) {
      * @param as A CopyOnWriteArrayList to map this function over.
      * @return A new CopyOnWriteArrayList with this function applied to each element.
      */
-    public CopyOnWriteArrayList<B> mapJ(final CopyOnWriteArrayList<A> as) {
+    public final CopyOnWriteArrayList<B> mapJ(final CopyOnWriteArrayList<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -603,7 +603,7 @@ public CopyOnWriteArrayList<B> mapJ(final CopyOnWriteArrayList<A> as) {
      * @param as A ConcurrentLinkedQueue to map this function over.
      * @return A new ConcurrentLinkedQueue with this function applied to each element.
      */
-    public ConcurrentLinkedQueue<B> mapJ(final ConcurrentLinkedQueue<A> as) {
+    public final ConcurrentLinkedQueue<B> mapJ(final ConcurrentLinkedQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -613,7 +613,7 @@ public ConcurrentLinkedQueue<B> mapJ(final ConcurrentLinkedQueue<A> as) {
      * @param as An ArrayBlockingQueue to map this function over.
      * @return A new ArrayBlockingQueue with this function applied to each element.
      */
-    public ArrayBlockingQueue<B> mapJ(final ArrayBlockingQueue<A> as) {
+    public final ArrayBlockingQueue<B> mapJ(final ArrayBlockingQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -624,7 +624,7 @@ public ArrayBlockingQueue<B> mapJ(final ArrayBlockingQueue<A> as) {
      * @param as A TreeSet to map this function over.
      * @return A new TreeSet with this function applied to each element.
      */
-    public TreeSet<B> mapJ(final TreeSet<A> as) {
+    public final TreeSet<B> mapJ(final TreeSet<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -634,7 +634,7 @@ public TreeSet<B> mapJ(final TreeSet<A> as) {
      * @param as A PriorityQueue to map this function over.
      * @return A new PriorityQueue with this function applied to each element.
      */
-    public PriorityQueue<B> mapJ(final PriorityQueue<A> as) {
+    public final PriorityQueue<B> mapJ(final PriorityQueue<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -644,7 +644,7 @@ public PriorityQueue<B> mapJ(final PriorityQueue<A> as) {
      * @param as A LinkedList to map this function over.
      * @return A new LinkedList with this function applied to each element.
      */
-    public LinkedList<B> mapJ(final LinkedList<A> as) {
+    public final LinkedList<B> mapJ(final LinkedList<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
@@ -654,15 +654,15 @@ public LinkedList<B> mapJ(final LinkedList<A> as) {
      * @param as An ArrayList to map this function over.
      * @return A new ArrayList with this function applied to each element.
      */
-    public ArrayList<B> mapJ(final ArrayList<A> as) {
+    public final ArrayList<B> mapJ(final ArrayList<A> as) {
         return F1Functions.mapJ(this, as);
     }
 
-    public <C> F1W<A, C> map(F<B, C> f) {
+    public final <C> F1W<A, C> map(F<B, C> f) {
         return lift(F1Functions.map(this, f));
     }
 
-    public <C> F1W<C, B> contramap(F<C, A> f) {
+    public final <C> F1W<C, B> contramap(F<C, A> f) {
         return lift(F1Functions.contramap(this, f));
     }
 
@@ -673,7 +673,7 @@ public F1WFunc(F<A, B> f) {
         }
 
         @Override
-        public B f(A a) {
+        public final B f(A a) {
             return func.f(a);
         }
     }
diff --git a/core/src/main/java/fj/F2W.java b/core/src/main/java/fj/F2W.java
index eb2fb590..1f35855a 100644
--- a/core/src/main/java/fj/F2W.java
+++ b/core/src/main/java/fj/F2W.java
@@ -14,7 +14,7 @@ public abstract class F2W<A, B, C> implements F2<A, B, C> {
      * @param a The <code>A</code> to which to apply this function.
      * @return The function partially applied to the given argument.
      */
-    public F1W<B, C> f(final A a) {
+    public final F1W<B, C> f(final A a) {
         return F1W.lift(F2Functions.f(this, a));
     }
 
@@ -23,7 +23,7 @@ public F1W<B, C> f(final A a) {
      *
      * @return a wrapped function of arity-1 that returns another wrapped function.
      */
-    public F1W<A, F<B, C>> curry() {
+    public final F1W<A, F<B, C>> curry() {
         return F1W.lift(F2Functions.curry(this));
     }
 
@@ -32,7 +32,7 @@ public F1W<A, F<B, C>> curry() {
      *
      * @return A new function with the arguments of this function flipped.
      */
-    public F2W<B, A, C> flip() {
+    public final F2W<B, A, C> flip() {
         return lift(F2Functions.flip(this));
     }
 
@@ -41,7 +41,7 @@ public F2W<B, A, C> flip() {
      *
      * @return A new function that calls this function with the elements of a given tuple.
      */
-    public F1W<P2<A, B>, C> tuple() {
+    public final F1W<P2<A, B>, C> tuple() {
         return F1W.lift(F2Functions.tuple(this));
     }
 
@@ -50,7 +50,7 @@ public F1W<P2<A, B>, C> tuple() {
      *
      * @return This function promoted to transform Arrays.
      */
-    public F2W<Array<A>, Array<B>, Array<C>> arrayM() {
+    public final F2W<Array<A>, Array<B>, Array<C>> arrayM() {
         return lift(F2Functions.arrayM(this));
     }
 
@@ -59,7 +59,7 @@ public F2W<Array<A>, Array<B>, Array<C>> arrayM() {
      *
      * @return This function promoted to transform Promises.
      */
-    public F2W<Promise<A>, Promise<B>, Promise<C>> promiseM() {
+    public final F2W<Promise<A>, Promise<B>, Promise<C>> promiseM() {
         return lift(F2Functions.promiseM(this));
     }
 
@@ -68,7 +68,7 @@ public F2W<Promise<A>, Promise<B>, Promise<C>> promiseM() {
      *
      * @return This function promoted to transform Iterables.
      */
-    public F2W<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
+    public final F2W<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
         return lift(F2Functions.iterableM(this));
     }
 
@@ -77,7 +77,7 @@ public F2W<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
      *
      * @return This function promoted to transform Lists.
      */
-    public F2W<List<A>, List<B>, List<C>> listM() {
+    public final F2W<List<A>, List<B>, List<C>> listM() {
         return lift(F2Functions.listM(this));
     }
 
@@ -86,7 +86,7 @@ public F2W<List<A>, List<B>, List<C>> listM() {
      *
      * @return This function promoted to transform non-empty lists.
      */
-    public F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
+    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
         return lift(F2Functions.nelM(this));
     }
 
@@ -95,7 +95,7 @@ public F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
      *
      * @return This function promoted to transform Options.
      */
-    public F2W<Option<A>, Option<B>, Option<C>> optionM() {
+    public final F2W<Option<A>, Option<B>, Option<C>> optionM() {
         return lift(F2Functions.optionM(this));
     }
 
@@ -105,7 +105,7 @@ public F2W<Option<A>, Option<B>, Option<C>> optionM() {
      * @param o An ordering for the result of the promoted function.
      * @return This function promoted to transform Sets.
      */
-    public F2W<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
+    public final F2W<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
         return lift(F2Functions.setM(this, o));
     }
 
@@ -114,7 +114,7 @@ public F2W<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
      *
      * @return This function promoted to transform Streams.
      */
-    public F2W<Stream<A>, Stream<B>, Stream<C>> streamM() {
+    public final F2W<Stream<A>, Stream<B>, Stream<C>> streamM() {
         return lift(F2Functions.streamM(this));
     }
 
@@ -123,7 +123,7 @@ public F2W<Stream<A>, Stream<B>, Stream<C>> streamM() {
      *
      * @return This function promoted to transform Trees.
      */
-    public F2W<Tree<A>, Tree<B>, Tree<C>> treeM() {
+    public final F2W<Tree<A>, Tree<B>, Tree<C>> treeM() {
         return lift(F2Functions.treeM(this));
     }
 
@@ -132,7 +132,7 @@ public F2W<Tree<A>, Tree<B>, Tree<C>> treeM() {
      *
      * @return A function that zips two arrays with this function.
      */
-    public F2W<Array<A>, Array<B>, Array<C>> zipArrayM() {
+    public final F2W<Array<A>, Array<B>, Array<C>> zipArrayM() {
         return lift(F2Functions.zipArrayM(this));
     }
 
@@ -141,7 +141,7 @@ public F2W<Array<A>, Array<B>, Array<C>> zipArrayM() {
      *
      * @return A function that zips two iterables with this function.
      */
-    public F2W<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
+    public final F2W<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
         return lift(F2Functions.zipIterableM(this));
     }
 
@@ -150,7 +150,7 @@ public F2W<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
      *
      * @return A function that zips two lists with this function.
      */
-    public F2W<List<A>, List<B>, List<C>> zipListM() {
+    public final F2W<List<A>, List<B>, List<C>> zipListM() {
         return lift(F2Functions.zipListM(this));
     }
 
@@ -160,7 +160,7 @@ public F2W<List<A>, List<B>, List<C>> zipListM() {
      *
      * @return A function that zips two streams with this function.
      */
-    public F2W<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
+    public final F2W<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
         return lift(F2Functions.zipStreamM(this));
     }
 
@@ -169,7 +169,7 @@ public F2W<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
      *
      * @return A function that zips two non-empty lists with this function.
      */
-    public F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
+    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
         return lift(F2Functions.zipNelM(this));
     }
 
@@ -179,7 +179,7 @@ public F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
      * @param o An ordering for the resulting set.
      * @return A function that zips two sets with this function.
      */
-    public F2W<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
+    public final F2W<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
         return lift(F2Functions.zipSetM(this, o));
     }
 
@@ -189,7 +189,7 @@ public F2W<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
      *
      * @return A function that zips two trees with this function.
      */
-    public F2W<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
+    public final F2W<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
         return lift(F2Functions.zipTreeM(this));
     }
 
@@ -199,7 +199,7 @@ public F2W<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
      *
      * @return A function that zips two zippers with this function.
      */
-    public F2W<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
+    public final F2W<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
         return lift(F2Functions.zipZipperM(this));
     }
 
@@ -209,23 +209,23 @@ public F2W<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
      *
      * @return A function that zips two TreeZippers with this function.
      */
-    public F2W<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM() {
+    public final F2W<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM() {
         return lift(F2Functions.zipTreeZipperM(this));
     }
 
-    public <Z> F2W<Z, B, C> contramapFirst(F<Z, A> f) {
+    public final <Z> F2W<Z, B, C> contramapFirst(F<Z, A> f) {
         return lift(F2Functions.contramapFirst(this, f));
     }
 
-    public <Z> F2W<A, Z, C> contramapSecond(F<Z, B> f) {
+    public final <Z> F2W<A, Z, C> contramapSecond(F<Z, B> f) {
         return lift(F2Functions.contramapSecond(this, f));
     }
 
-    public <X, Y> F2W<X, Y, C> contramap(F<X, A> f, F<Y, B> g) {
+    public final <X, Y> F2W<X, Y, C> contramap(F<X, A> f, F<Y, B> g) {
         return lift(F2Functions.contramap(this, f, g));
     }
 
-    public <Z> F2W<A, B, Z> map(F<C, Z> f) {
+    public final <Z> F2W<A, B, Z> map(F<C, Z> f) {
         return lift(F2Functions.map(this, f));
     }
 
@@ -237,7 +237,7 @@ public F2WFunc(F2<A, B, C> f) {
         }
 
         @Override
-        public C f(A a, B b) {
+        public final C f(A a, B b) {
             return func.f(a, b);
         }
     }
diff --git a/core/src/main/java/fj/LcgRng.java b/core/src/main/java/fj/LcgRng.java
index 50ee9e03..215b3572 100644
--- a/core/src/main/java/fj/LcgRng.java
+++ b/core/src/main/java/fj/LcgRng.java
@@ -17,18 +17,18 @@ public LcgRng(long s) {
 		seed = s;
 	}
 
-    public long getSeed() {
+    public final long getSeed() {
         return seed;
     }
 
-	public P2<Rng, Integer> nextInt() {
+	public final P2<Rng, Integer> nextInt() {
         P2<Rng, Long> p = nextLong();
         int i = (int) p._2().longValue();
         return P.p(p._1(), i);
 	}
 
 
-	public P2<Rng, Long> nextLong() {
+	public final P2<Rng, Long> nextLong() {
         P2<Long, Long> p = nextLong(seed);
         return P.p(new LcgRng(p._1()), p._2());
     }
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 471c110f..bb682ad8 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -527,7 +527,7 @@ public static <A> Ord<A> hashEqualsOrd() {
 
   class OrdComparator implements Comparator<A> {
 	@Override
-    public int compare(A o1, A o2) {
+    public final int compare(A o1, A o2) {
 	    return Ord.this.compare(o1, o2).toInt();
     }
   }
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 5a1d9b8a..d6809da9 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -63,7 +63,7 @@ public static <A, B> F<P1<A>, P1<B>> map_(final F<A, B> f) {
      * @param f A function to apply to the value in a product-1.
      * @return The result of applying the given function to the value of given product-1.
      */
-    public <B> P1<B> bind(final F<A, P1<B>> f) {
+    public final <B> P1<B> bind(final F<A, P1<B>> f) {
         P1<A> self = this;
         return P.lazy(() -> f.f(self._1())._1());
     }
@@ -84,7 +84,7 @@ public static <A, B> F<A, P1<B>> curry(final F<A, B> f) {
      * @param cf The P1 function to apply.
      * @return A new P1 after applying the given P1 function to the first argument.
      */
-    public <B> P1<B> apply(final P1<F<A, B>> cf) {
+    public final <B> P1<B> apply(final P1<F<A, B>> cf) {
         P1<A> self = this;
         return cf.bind(f -> map_(f).f(self));
     }
@@ -96,14 +96,14 @@ public <B> P1<B> apply(final P1<F<A, B>> cf) {
      * @param f  The function to apply to the values in the given P1s.
      * @return A new P1 after performing the map, then final join.
      */
-    public <B, C> P1<C> bind(final P1<B> cb, final F<A, F<B, C>> f) {
+    public final <B, C> P1<C> bind(final P1<B> cb, final F<A, F<B, C>> f) {
         return cb.apply(map_(f).f(this));
     }
 
 	/**
 	 * Binds the given function to the values in the given P1s with a final join.
 	 */
-	public <B, C> P1<C> bind(final P1<B> cb, final F2<A, B, C> f) {
+	public final <B, C> P1<C> bind(final P1<B> cb, final F2<A, B, C> f) {
 		return bind(cb, F2W.lift(f).curry());
 	}
 
@@ -127,7 +127,7 @@ public static <A, B, C> F<P1<A>, F<P1<B>, P1<C>>> liftM2(final F<A, F<B, C>> f)
         return Function.curry((pa, pb) -> pa.bind(pb, f));
     }
 
-	public <B, C> P1<C> liftM2(P1<B> pb, F2<A, B, C> f) {
+	public final <B, C> P1<C> liftM2(P1<B> pb, F2<A, B, C> f) {
 		return P.lazy(() -> f.f(_1(), pb._1()));
 	}
 
@@ -183,7 +183,7 @@ public static <A> P1<Array<A>> sequence(final Array<P1<A>> as) {
      * @param f The function that takes A and produces a List<B> (non-deterministic result)
      * @return A List of P1<B>
      */
-    public <B> List<P1<B>> traverseList(final F<A, List<B>>  f){
+    public final <B> List<P1<B>> traverseList(final F<A, List<B>> f){
         return f.f(_1()).map(P::p);
     }
 
@@ -193,7 +193,7 @@ public <B> List<P1<B>> traverseList(final F<A, List<B>>  f){
      * @param f The function produces Either
      * @return An Either of  P1<B>
      */
-    public <B, X> Either<X, P1<B>> traverseEither(final F<A, Either<X, B>>  f){
+    public final <B, X> Either<X, P1<B>> traverseEither(final F<A, Either<X, B>> f){
         return f.f(_1()).right().map(P::p);
     }
 
@@ -203,7 +203,7 @@ public <B, X> Either<X, P1<B>> traverseEither(final F<A, Either<X, B>>  f){
      * @param f The function that produces Option
      * @return An Option of  P1<B>
      */
-    public <B> Option<P1<B>> traverseOption(final F<A, Option<B>>  f){
+    public final <B> Option<P1<B>> traverseOption(final F<A, Option<B>> f){
         return f.f(_1()).map(P::p);
     }
 
@@ -213,7 +213,7 @@ public <B> Option<P1<B>> traverseOption(final F<A, Option<B>>  f){
      * @param f The function might produces Validation
      * @return An Validation  of P1<B>
      */
-    public <B, E> Validation<E, P1<B>> traverseValidation(final F<A, Validation<E, B>> f){
+    public final <B, E> Validation<E, P1<B>> traverseValidation(final F<A, Validation<E, B>> f){
         return f.f(_1()).map(P::p);
     }
 
@@ -223,7 +223,7 @@ public <B, E> Validation<E, P1<B>> traverseValidation(final F<A, Validation<E, B
      * @param f The function that produces Stream
      * @return An Stream of  P1<B>
      */
-    public <B> Stream<P1<B>> traverseStream(final F<A, Stream<B>>  f){
+    public final <B> Stream<P1<B>> traverseStream(final F<A, Stream<B>> f){
         return f.f(_1()).map(P::p);
     }
 
@@ -233,7 +233,7 @@ public <B> Stream<P1<B>> traverseStream(final F<A, Stream<B>>  f){
        * @param f The function to map with.
        * @return A product with the given function applied.
        */
-      public <B> P1<B> map(final F<A, B> f) {
+      public final <B> P1<B> map(final F<A, B> f) {
           final P1<A> self = this;
         return P.lazy(() -> f.f(self._1()));
       }
@@ -247,7 +247,7 @@ public P1<A> memo() {
      *
      * @return A P1 that calls this P1 once and remembers the value for subsequent calls.
      */
-    public P1<A> hardMemo() { return new Memo<>(this); }
+    public final P1<A> hardMemo() { return new Memo<>(this); }
 
     /**
      * Like <code>memo</code>, but the memoized value is wrapped into a <code>WeakReference</code>
@@ -274,7 +274,7 @@ static class Memo<A> extends P1<A> {
 
       Memo(P1<A> self) { this.self = self; }
 
-      @Override public A _1() {
+      @Override public final A _1() {
         if (!initialized) {
           synchronized (this) {
             if (!initialized) {
@@ -288,7 +288,7 @@ static class Memo<A> extends P1<A> {
         return value;
       }
 
-      @Override public P1<A> memo() { return this; }
+      @Override public final P1<A> memo() { return this; }
     }
 
     abstract static class ReferenceMemo<A> extends P1<A> {
@@ -298,7 +298,7 @@ abstract static class ReferenceMemo<A> extends P1<A> {
 
       ReferenceMemo(final P1<A> self) { this.self = self; }
 
-      @Override public A _1() {
+      @Override public final A _1() {
         Option<A> o = v != null ? v.get() : null;
         if (o == null) {
           synchronized (latch) {
@@ -317,14 +317,16 @@ abstract static class ReferenceMemo<A> extends P1<A> {
 
     static class WeakReferenceMemo<A> extends ReferenceMemo<A> {
       WeakReferenceMemo(P1<A> self) { super(self); }
-      @Override Reference<Option<A>> newReference(final Option<A> o) { return new WeakReference<>(o); }
-      @Override public P1<A> weakMemo() { return this; }
+      @Override
+      final Reference<Option<A>> newReference(final Option<A> o) { return new WeakReference<>(o); }
+      @Override public final P1<A> weakMemo() { return this; }
     }
 
     static class SoftReferenceMemo<A> extends ReferenceMemo<A> {
       SoftReferenceMemo(P1<A> self) { super(self); }
-      @Override Reference<Option<A>> newReference(final Option<A> o) { return new SoftReference<>(o); }
-      @Override public P1<A> softMemo() { return this; }
+      @Override
+      final Reference<Option<A>> newReference(final Option<A> o) { return new SoftReference<>(o); }
+      @Override public final P1<A> softMemo() { return this; }
     }
 
     /**
@@ -332,20 +334,20 @@ static class SoftReferenceMemo<A> extends ReferenceMemo<A> {
      *
      * @return A constant function that always uses this value.
      */
-    public <B> F<B, A> constant() { return Function.constant(_1()); }
+    public final <B> F<B, A> constant() { return Function.constant(_1()); }
 
     @Override
-    public String toString() {
+    public final String toString() {
 		return Show.p1Show(Show.<A>anyShow()).showS(this);
 	}
 
     @Override
-    public boolean equals(Object other) {
+    public final boolean equals(Object other) {
         return Equal.equals0(P1.class, this, other, () -> Equal.p1Equal(Equal.anyEqual()));
     }
 
     @Override
-    public int hashCode() {
+    public final int hashCode() {
         return Hash.p1Hash(Hash.<A>anyHash()).hash(this);
     }
 
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index be3be69b..521fc14d 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -27,12 +27,12 @@ public abstract class P2<A, B> {
   public abstract B _2();
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P2.class, this, other, () -> Equal.p2Equal(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p2Hash(Hash.<A>anyHash(), Hash.<B>anyHash()).hash(this);
   }
 
@@ -311,7 +311,7 @@ public static <A, B, C> F2<A, B, C> untuple(final F<P2<A, B>, C> f) {
 
 
     @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p2Show(Show.<A>anyShow(), Show.<B>anyShow()).showS(this);
 	}
 
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index c6bc38a9..26c51b05 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -174,18 +174,18 @@ public static <A, B, C> F<P3<A, B, C>, C> __3() {
   }
 
     @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p3Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow()).showS(this);
 	}
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P3.class, this, other, 
         () -> Equal.p3Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p3Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index 6181b75e..c2f94f8f 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -243,18 +243,18 @@ public static <A, B, C, D> F<P4<A, B, C, D>, D> __4() {
   }
 
   @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p4Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow(), Show.<D>anyShow()).showS(this);
 	}
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P4.class, this, other,
         () -> Equal.p4Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p4Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash(), Hash.<D>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 2fd74ebe..902da93c 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -318,18 +318,18 @@ public static <A, B, C, D, E> F<P5<A, B, C, D, E>, E> __5() {
   }
 
   @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p5Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow(), Show.<D>anyShow(), Show.<E>anyShow()).showS(this);
 	}
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P5.class, this, other,
         () -> Equal.p5Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p5Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash(), Hash.<D>anyHash(), Hash.<E>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index 5c679a2c..37f5fe6c 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -404,19 +404,19 @@ public F _6() {
   }
 
     @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p6Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow(), Show.<D>anyShow(), Show.<E>anyShow(), Show.<F>anyShow()).showS(this);
 	}
 
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P6.class, this, other,
         () -> Equal.p6Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p6Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash(), Hash.<D>anyHash(), Hash.<E>anyHash(), Hash.<F>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index eb0cb913..e2673183 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -495,18 +495,18 @@ public G _7() {
   }
 
   @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p7Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow(), Show.<D>anyShow(), Show.<E>anyShow(), Show.<F>anyShow(), Show.<G>anyShow()).showS(this);
 	}
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P7.class, this, other,
         () -> Equal.p7Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p7Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash(), Hash.<D>anyHash(), Hash.<E>anyHash(), Hash.<F>anyHash(), Hash.<G>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index de13749b..cfa916eb 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -597,18 +597,18 @@ public H _8() {
   }
 
   @Override
-	public String toString() {
+	public final String toString() {
 		return Show.p8Show(Show.<A>anyShow(), Show.<B>anyShow(), Show.<C>anyShow(), Show.<D>anyShow(), Show.<E>anyShow(), Show.<F>anyShow(), Show.<G>anyShow(), Show.<H>anyShow()).showS(this);
 	}
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(P8.class, this, other,
         () -> Equal.p8Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.p8Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash(), Hash.<D>anyHash(), Hash.<E>anyHash(), Hash.<F>anyHash(), Hash.<G>anyHash(), Hash.<H>anyHash()).hash(this);
   }
 
diff --git a/core/src/main/java/fj/Rng.java b/core/src/main/java/fj/Rng.java
index 45f03c06..20b3358f 100644
--- a/core/src/main/java/fj/Rng.java
+++ b/core/src/main/java/fj/Rng.java
@@ -10,12 +10,12 @@ public abstract class Rng {
     public abstract P2<Rng, Long> nextLong();
 
     // [low, high] inclusive
-    public P2<Rng, Integer> range(int low, int high) {
+    public final P2<Rng, Integer> range(int low, int high) {
         return nextNatural().map2(x -> (x % (high - low + 1)) + low);
     }
 
 
-	public P2<Rng, Integer> nextNatural() {
+	public final P2<Rng, Integer> nextNatural() {
 		return nextInt().map2(x -> x < 0 ? -(x + 1) : x);
 	}
 
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index fa07df3c..bd69ae7a 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -18,7 +18,7 @@ public abstract class Trampoline<A> {
   private abstract static class Normal<A> extends Trampoline<A> {
     public abstract <R> R foldNormal(final F<A, R> pure, final F<P1<Trampoline<A>>, R> k);
 
-    public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
+    public final <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
       return codense(this, f);
     }
   }
@@ -199,7 +199,7 @@ public static <A> F<Trampoline<A>, Either<P1<Trampoline<A>>, A>> resume_() {
    * @return The end result of this computation.
    */
   @SuppressWarnings("LoopStatementThatDoesntLoop")
-  public A run() {
+  public final A run() {
     Trampoline<A> current = this;
     while (true) {
       final Either<P1<Trampoline<A>>, A> x = current.resume();
@@ -252,7 +252,7 @@ public static <A, B, C> F<Trampoline<A>, F<Trampoline<B>, Trampoline<C>>> liftM2
    * @return A new trampoline that runs this trampoline and the given trampoline simultaneously.
    */
   @SuppressWarnings("LoopStatementThatDoesntLoop")
-  public <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B, C> f) {
+  public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B, C> f) {
     final Either<P1<Trampoline<A>>, A> ea = resume();
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 0d944415..77dea3c3 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -92,12 +92,12 @@ public final <X, Y> Either<X, Y> bimap(final F<A, X> left, final F<B, Y> right)
   }
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(Either.class, this, other, () -> Equal.eitherEqual(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.eitherHash(Hash.<A>anyHash(), Hash.<B>anyHash()).hash(this);
   }
 
@@ -802,7 +802,7 @@ public static <B, X> Either<X, List<B>> sequenceRight(final List<Either<X, B>> a
    *
    * @return traversed value
    */
-  public <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
+  public final <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
     return right().traverseList(f);
   }
 
@@ -811,7 +811,7 @@ public <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
      *
      * @return traversed value
   */
-    public <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
+    public final <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
         return left().traverseList(f);
     }
 
@@ -820,7 +820,7 @@ public <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
    *
    * @return traversed value
    */
-  public <C> IO<Either<A, C>> traverseIORight(final F<B, IO<C>> f) {
+  public final <C> IO<Either<A, C>> traverseIORight(final F<B, IO<C>> f) {
     return right().traverseIO(f);
   }
 
@@ -829,7 +829,7 @@ public <C> IO<Either<A, C>> traverseIORight(final F<B, IO<C>> f) {
    *
    * @return traversed value
    */
-  public <C> IO<Either<C, B>> traverseIOLeft(final F<A, IO<C>> f) {
+  public final <C> IO<Either<C, B>> traverseIOLeft(final F<A, IO<C>> f) {
     return left().traverseIO(f);
   }
 
@@ -838,7 +838,7 @@ public <C> IO<Either<C, B>> traverseIOLeft(final F<A, IO<C>> f) {
    *
    * @return traversed value
    */
-  public <C> Option<Either<A, C>> traverseOptionRight(final F<B, Option<C>> f) {
+  public final <C> Option<Either<A, C>> traverseOptionRight(final F<B, Option<C>> f) {
     return right().traverseOption(f);
   }
 
@@ -847,7 +847,7 @@ public <C> Option<Either<A, C>> traverseOptionRight(final F<B, Option<C>> f) {
    *
    * @return traversed value
    */
-  public <C> Option<Either<C, B>> traverseOptionLeft(final F<A, Option<C>> f) {
+  public final <C> Option<Either<C, B>> traverseOptionLeft(final F<A, Option<C>> f) {
     return left().traverseOption(f);
   }
 
@@ -856,7 +856,7 @@ public <C> Option<Either<C, B>> traverseOptionLeft(final F<A, Option<C>> f) {
    *
    * @return traversed value
    */
-  public <C> Stream<Either<A, C>> traverseStreamRight(final F<B, Stream<C>> f) {
+  public final <C> Stream<Either<A, C>> traverseStreamRight(final F<B, Stream<C>> f) {
     return right().traverseStream(f);
   }
 
@@ -865,7 +865,7 @@ public <C> Stream<Either<A, C>> traverseStreamRight(final F<B, Stream<C>> f) {
    *
    * @return traversed value
    */
-  public <C> Stream<Either<C, B>> traverseStreamLeft(final F<A, Stream<C>> f) {
+  public final <C> Stream<Either<C, B>> traverseStreamLeft(final F<A, Stream<C>> f) {
     return left().traverseStream(f);
   }
 
@@ -913,7 +913,7 @@ public static <A, B> List<B> rights(final List<Either<A, B>> es) {
     return es.foldRight(e -> bs -> e.isRight() ? bs.cons(e.right().value()) : bs, List.nil());
   }
 
-    public String toString() {
+    public final String toString() {
         return Show.eitherShow(Show.<A>anyShow(), Show.<B>anyShow()).showS(this);
     }
 
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 399cc016..15171e43 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -166,7 +166,7 @@ public final Option<A> toOption() {
    *
    * @return The optional head of the list.
    */
-  public Option<A> headOption() {
+  public final Option<A> headOption() {
     return isEmpty() ? Option.none() : some(head());
   }
 
@@ -611,7 +611,7 @@ public final <B> List<B> sequence(final List<B> bs) {
      * @param f The function that produces Option value
      * @return  none if applying f returns none to any element of the list or f mapped list in some .
      */
-    public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
+    public final <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
         return foldRight(
                 (a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),
                 some(List.nil())
@@ -624,35 +624,35 @@ public <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
      * @param f The function that produces Either value.
      * @return  error in left or f mapped list in right.
      */
-    public <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {
+    public final <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {
         return foldRight(
                 (a, acc) -> f.f(a).right().bind(e -> acc.right().map(es -> es.cons(e))),
                 Either.right(List.nil())
         );
     }
 
-    public <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
+    public final <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
         return foldRight(
                 (a, acc) -> f.f(a).bind(s -> acc.map(ss -> ss.cons(s))),
                 Stream.nil()
         );
     }
 
-    public <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
+    public final <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
         return foldRight(
                 (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
                 p(List.nil())
         );
     }
 
-    public <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
+    public final <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
         return this.foldRight(
                 (a, acc) -> IOFunctions.bind(f.f(a), b -> IOFunctions.map(acc, bs -> bs.cons(b))),
                 IOFunctions.unit(List.nil())
         );
     }
 
-  public <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
+  public final <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
     return this.foldRight(
         (a, acc) -> Function.bind(acc,
             (bs) -> Function.compose(bs::cons, f.f(a))),
@@ -660,31 +660,31 @@ public <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
         );
   }
 
-  public <B> Trampoline<List<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
+  public final <B> Trampoline<List<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
         Trampoline.pure(List.nil()));
   }
 
-  public <B> Promise<List<B>> traversePromise(final F<A, Promise<B>> f) {
+  public final <B> Promise<List<B>> traversePromise(final F<A, Promise<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.fmap(bs -> bs.cons(b))),
         Promise.promise(Strategy.idStrategy(), p(List.nil())));
   }
 
-  public <B> List<List<B>> traverseList(final F<A, List<B>> f) {
+  public final <B> List<List<B>> traverseList(final F<A, List<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
         single(List.nil()));
   }
 
-  public <E, B> Validation<E, List<B>> traverseValidation(final F<A, Validation<E, B>> f) {
+  public final <E, B> Validation<E, List<B>> traverseValidation(final F<A, Validation<E, B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
         Validation.success(List.nil()));
   }
 
-  public <B> V2<List<B>> traverseV2(final F<A, V2<B>> f) {
+  public final <B> V2<List<B>> traverseV2(final F<A, V2<B>> f) {
     return foldRight(
         (a, acc) -> acc.apply(f.f(a).<F<List<B>, List<B>>> map(e -> es -> es.cons(e))),
         v(List.nil(), List.nil()));
@@ -902,7 +902,7 @@ public final List<List<A>> partition(final int n) {
    *
    * @param f Predicate function.
    */
-  public P2<List<A>, List<A>> partition(F<A, Boolean> f) {
+  public final P2<List<A>, List<A>> partition(F<A, Boolean> f) {
     P2<List<A>, List<A>> p2 = foldLeft(acc -> a ->
       f.f(a) ? p(acc._1().cons(a), acc._2()) : p(acc._1(), acc._2().cons(a)),
       p(nil(), nil())
@@ -1172,7 +1172,7 @@ public static <A> F<List<A>, A> head_() {
 	 * Reutrns the tail of the list, if any.
 	 * @return The optional tail of the list.
 	 */
-	public Option<List<A>> tailOption() {
+	public final Option<List<A>> tailOption() {
 		return isEmpty() ? none() : some(tail());
 	}
 
@@ -1410,7 +1410,7 @@ public final <B, C, D> TreeMap<B, D> groupBy(
    * @param eq The equality test.
    * @return Whether or not all elements in the list are equal according to the given equality test.
    */
-  public boolean allEqual(final Equal<A> eq) {
+  public final boolean allEqual(final Equal<A> eq) {
     return isEmpty() || tail().isEmpty() || eq.eq(head(), tail().head()) && tail().allEqual(eq);
   }
 
@@ -2066,7 +2066,7 @@ private void copy() {
      * @param obj the other object to check for equality against.
      * @return true if this list is equal to the provided argument
      */
-    @Override public boolean equals( final Object obj ) {
+    @Override public final boolean equals(final Object obj) {
         return Equal.equals0(List.class, this, obj, () -> Equal.listEqual(Equal.anyEqual()));
     }
 
@@ -2077,7 +2077,7 @@ private void copy() {
      * @return the hash code for this list.
      */
     @Override
-    public int hashCode() {
+    public final int hashCode() {
         return Hash.listHash(Hash.<A>anyHash()).hash(this);
     }
 
@@ -2087,14 +2087,14 @@ public int hashCode() {
      *
      * @return a String representation of the list
      */
-    @Override public String toString() {
+    @Override public final String toString() {
         return Show.listShow(Show.<A>anyShow()).showS(this);
     }
 
     /**
      * True if and only if the list has one element. Runs in constant time.
      */
-    public boolean isSingle() {
+    public final boolean isSingle() {
         return isNotEmpty() && tail().isEmpty();
     }
 
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 1ec77980..a74d2495 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -51,7 +51,7 @@ private Option() {
   }
 
   @Override
-  public String toString() {
+  public final String toString() {
     return optionShow(Show.<A>anyShow()).showS(this);
   }
 
@@ -411,44 +411,44 @@ public final <B> Option<B> sequence(final Option<B> o) {
     return bind(c);
   }
 
-  public <L, B> Either<L, Option<B>> traverseEither(F<A, Either<L, B>> f) {
+  public final <L, B> Either<L, Option<B>> traverseEither(F<A, Either<L, B>> f) {
     return map(a -> f.f(a).right().map(Option::some)).orSome(Either.right(none()));
   }
 
-  public <B> IO<Option<B>> traverseIO(F<A, IO<B>> f) {
+  public final <B> IO<Option<B>> traverseIO(F<A, IO<B>> f) {
     return map(a -> IOFunctions.map(f.f(a), Option::some)).orSome(IOFunctions.lazy(Option::none));
   }
 
-  public <B> List<Option<B>> traverseList(F<A, List<B>> f) {
+  public final <B> List<Option<B>> traverseList(F<A, List<B>> f) {
     return map(a -> f.f(a).map(Option::some)).orSome(List.list());
   }
 
-  public <B> Option<Option<B>> traverseOption(F<A, Option<B>> f) {
+  public final <B> Option<Option<B>> traverseOption(F<A, Option<B>> f) {
     return map(f);
   }
 
-  public <B> Stream<Option<B>> traverseStream(F<A, Stream<B>> f) {
+  public final <B> Stream<Option<B>> traverseStream(F<A, Stream<B>> f) {
     return map(a -> f.f(a).map(Option::some)).orSome(Stream.nil());
   }
 
-  public <B> P1<Option<B>> traverseP1(F<A, P1<B>> f) {
+  public final <B> P1<Option<B>> traverseP1(F<A, P1<B>> f) {
     return map(a -> f.f(a).map(Option::some)).orSome(p(none()));
   }
 
-  public <B> Seq<Option<B>> traverseSeq(F<A, Seq<B>> f) {
+  public final <B> Seq<Option<B>> traverseSeq(F<A, Seq<B>> f) {
     return map(a -> f.f(a).map(Option::some)).orSome(Seq.empty());
   }
 
-  public <B> Set<Option<B>> traverseSet(Ord<B> ord, F<A, Set<B>> f) {
+  public final <B> Set<Option<B>> traverseSet(Ord<B> ord, F<A, Set<B>> f) {
     Ord<Option<B>> optOrd = Ord.optionOrd(ord);
     return map(a -> f.f(a).map(optOrd, Option::some)).orSome(Set.empty(optOrd));
   }
 
-  public <B> F2<Ord<B>, F<A, Set<B>>, Set<Option<B>>> traverseSet() {
+  public final <B> F2<Ord<B>, F<A, Set<B>>, Set<Option<B>>> traverseSet() {
     return this::traverseSet;
   }
 
-  public <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<E, B>> f) {
+  public final <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<E, B>> f) {
     return map(a -> f.f(a).map(Option::some)).orSome(Validation.success(none()));
   }
 
@@ -608,7 +608,7 @@ public final boolean exists(final F<A, Boolean> f) {
   }
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(Option.class, this, other, () -> Equal.optionEqual(Equal.anyEqual()));
   }
 
@@ -796,7 +796,7 @@ public static Option<String> fromString(final String s) {
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.optionHash(Hash.<A>anyHash()).hash(this);
   }
 
@@ -836,7 +836,7 @@ public static <A, B, C> F<Option<A>, F<Option<B>, Option<C>>> liftM2(final F<A,
 	 * @param f A function to lift.
 	 * @return An optional result.
 	 */
-	public <B, C> Option<C> liftM2(final Option<B> ob, final F2<A, B, C> f) {
+	public final <B, C> Option<C> liftM2(final Option<B> ob, final F2<A, B, C> f) {
 		return bind(a -> ob.map(b -> f.f(a, b)));
 	}
 
diff --git a/core/src/main/java/fj/data/Reader.java b/core/src/main/java/fj/data/Reader.java
index 042db624..af66c87e 100644
--- a/core/src/main/java/fj/data/Reader.java
+++ b/core/src/main/java/fj/data/Reader.java
@@ -15,7 +15,7 @@ public Reader(F<A, B> f) {
 		function = f;
 	}
 
-	public F<A, B> getFunction() {
+	public final F<A, B> getFunction() {
 		return function;
 	}
 
@@ -27,23 +27,23 @@ public static <A, B> Reader<A, B> constant(B b) {
 		return unit(a -> b);
 	}
 
-	public B f(A a) {
+	public final B f(A a) {
 		return function.f(a);
 	}
 
-	public <C> Reader<A, C> map(F<B, C> f) {
+	public final <C> Reader<A, C> map(F<B, C> f) {
 		return unit(F1Functions.andThen(function, f));
 	}
 
-	public <C> Reader<A, C> andThen(F<B, C> f) {
+	public final <C> Reader<A, C> andThen(F<B, C> f) {
 		return map(f);
 	}
 
-	public <C> Reader<A, C> flatMap(F<B, Reader<A, C>> f) {
+	public final <C> Reader<A, C> flatMap(F<B, Reader<A, C>> f) {
 		return unit(a -> f.f(function.f(a)).f(a));
 	}
 
-	public <C> Reader<A, C> bind(F<B, Reader<A, C>> f) {
+	public final <C> Reader<A, C> bind(F<B, Reader<A, C>> f) {
 		return flatMap(f);
 	}
 
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 42ce0bac..35b3c683 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -142,17 +142,17 @@ public static <A> Set<A> empty(final Ord<A> ord) {
   }
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(Set.class, this, other, () -> Equal.setEqual(Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.setHash(Hash.<A>anyHash()).hash(this);
   }
 
   @Override
-  public String toString() {
+  public final String toString() {
     return Show.setShow(Show.<A>anyShow()).showS(this);
   }
 
@@ -467,11 +467,11 @@ public static <A> F<Set<A>, F<Set<A>, Set<A>>> minus() {
     return curry(Set::minus);
   }
 
-    public Option<A> min() {
+    public final Option<A> min() {
         return isEmpty() ? none() : l().min().orElse(some(head()));
     }
 
-    public Option<A> max() {
+    public final Option<A> max() {
         return isEmpty() ? none() : r().max().orElse(some(head()));
     }
 
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 4abde573..01e1756b 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -1258,25 +1258,25 @@ public final boolean forall(final F<A, Boolean> f) {
   }
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(Stream.class, this, other, () -> Equal.streamEqual(Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.streamHash(Hash.<A>anyHash()).hash(this);
   }
 
   @Override
-  public String toString() {
+  public final String toString() {
     return toStringLazy();
   }
 
-  public String toStringLazy() {
+  public final String toStringLazy() {
     return isEmpty() ? "Nil()" : "Cons(" + Show.<A>anyShow().showS(head()) + ", ?)";
   }
 
-  public String toStringEager() {
+  public final String toStringEager() {
     return Show.streamShow(Show.<A>anyShow()).showS(this);
   }
 
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 9d82596b..58aa5e9c 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -31,7 +31,7 @@ protected Validation(final Either<E, T> e) {
    *
    * @return <code>true</code> if this is a failure, <code>false</code> otherwise.
    */
-  public boolean isFail() {
+  public final boolean isFail() {
     return e.isLeft();
   }
 
@@ -40,7 +40,7 @@ public boolean isFail() {
    *
    * @return <code>true</code> if this is a success, <code>false</code> otherwise.
    */
-  public boolean isSuccess() {
+  public final boolean isSuccess() {
     return e.isRight();
   }
 
@@ -49,7 +49,7 @@ public boolean isSuccess() {
    *
    * @return the failing value, or throws an error if there is no failing value.
    */
-  public E fail() {
+  public final E fail() {
     if (isFail())
       return e.left().value();
     else
@@ -61,7 +61,7 @@ public E fail() {
    *
    * @return the success value, or throws an error if there is no success value.
    */
-  public T success() {
+  public final T success() {
     if (isSuccess())
       return e.right().value();
     else
@@ -75,7 +75,7 @@ public T success() {
    * @param success The function to call if this succeeded.
    * @return The reduced value.
    */
-  public <X> X validation(final F<E, X> fail, final F<T, X> success) {
+  public final <X> X validation(final F<E, X> fail, final F<T, X> success) {
     return e.either(fail, success);
   }
 
@@ -84,7 +84,7 @@ public <X> X validation(final F<E, X> fail, final F<T, X> success) {
    *
    * @return a failing projection of this validation.
    */
-  public FailProjection<E, T> f() {
+  public final FailProjection<E, T> f() {
     return new FailProjection<>(this);
   }
 
@@ -93,7 +93,7 @@ public FailProjection<E, T> f() {
    *
    * @return An either projection of this validation.
    */
-  public Either<E, T> toEither() {
+  public final Either<E, T> toEither() {
     return e;
   }
 
@@ -103,7 +103,7 @@ public Either<E, T> toEither() {
    * @param err The error message to fail with.
    * @return The success value.
    */
-  public T successE(final F0<String> err) {
+  public final T successE(final F0<String> err) {
     return e.right().valueE(err);
   }
 
@@ -113,7 +113,7 @@ public T successE(final F0<String> err) {
    * @param err The error message to fail with.
    * @return The success value.
    */
-  public T successE(final String err) {
+  public final T successE(final String err) {
     return e.right().valueE(p(err));
   }
 
@@ -123,7 +123,7 @@ public T successE(final String err) {
    * @param t The value to return if this is failure.
    * @return The success value or the given value.
    */
-  public T orSuccess(final F0<T> t) {
+  public final T orSuccess(final F0<T> t) {
     return e.right().orValue(t);
   }
 
@@ -133,7 +133,7 @@ public T orSuccess(final F0<T> t) {
    * @param t The value to return if this is failure.
    * @return The success value or the given value.
    */
-  public T orSuccess(final T t) {
+  public final T orSuccess(final T t) {
     return e.right().orValue(p(t));
   }
 
@@ -143,7 +143,7 @@ public T orSuccess(final T t) {
    * @param f The function to execute on the failing value.
    * @return The success value or the application of the given function to the failing value.
    */
-  public T on(final F<E, T> f) {
+  public final T on(final F<E, T> f) {
     return e.right().on(f);
   }
 
@@ -153,7 +153,7 @@ public T on(final F<E, T> f) {
    * @param f The side-effect to execute.
    * @return The unit value.
    */
-  public Unit foreach(final F<T, Unit> f) {
+  public final Unit foreach(final F<T, Unit> f) {
     return e.right().foreach(f);
   }
 
@@ -162,7 +162,7 @@ public Unit foreach(final F<T, Unit> f) {
    *
    * @param f The side-effect to execute.
    */
-  public void foreachDoEffect(final Effect1<T> f) {
+  public final void foreachDoEffect(final Effect1<T> f) {
     e.right().foreachDoEffect(f);
   }
 
@@ -173,7 +173,7 @@ public void foreachDoEffect(final Effect1<T> f) {
    * @return A new validation with the function mapped.
    */
   @SuppressWarnings("unchecked")
-  public <A> Validation<E, A> map(final F<T, A> f) {
+  public final <A> Validation<E, A> map(final F<T, A> f) {
     return isFail() ?
         Validation.fail(fail()) :
         Validation.success(f.f(success()));
@@ -186,7 +186,7 @@ public <A> Validation<E, A> map(final F<T, A> f) {
    * @return A new validation value after binding.
    */
   @SuppressWarnings("unchecked")
-  public <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
+  public final <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
     return isSuccess() ? f.f(success()) : Validation.fail(fail());
   }
 
@@ -196,7 +196,7 @@ public <A> Validation<E, A> bind(final F<T, Validation<E, A>> f) {
    * @param v The value to bind with.
    * @return A validation after binding.
    */
-  public <A> Validation<E, A> sequence(final Validation<E, A> v) {
+  public final <A> Validation<E, A> sequence(final Validation<E, A> v) {
     return bind(Function.constant(v));
   }
 
@@ -220,7 +220,7 @@ public static <E, A> Validation<E, List<A>> sequence(final Semigroup<E> s, final
    * @return <code>None</code> if this is a failure or if the given predicate <code>p</code> does not hold for the
    *         success value, otherwise, returns a success in <code>Some</code>.
    */
-  public <A> Option<Validation<A, T>> filter(final F<T, Boolean> f) {
+  public final <A> Option<Validation<A, T>> filter(final F<T, Boolean> f) {
     return e.right().<A>filter(f).map(Validation.validation());
   }
 
@@ -230,7 +230,7 @@ public <A> Option<Validation<A, T>> filter(final F<T, Boolean> f) {
    * @param v The validation of the function to apply on the success value.
    * @return The result of function application in validation.
    */
-  public <A> Validation<E, A> apply(final Validation<E, F<T, A>> v) {
+  public final <A> Validation<E, A> apply(final Validation<E, F<T, A>> v) {
     return v.bind(this::map);
   }
 
@@ -242,7 +242,7 @@ public <A> Validation<E, A> apply(final Validation<E, F<T, A>> v) {
    * @return <code>true</code> if this is a failure or returns the result of the application of the given
    *         function to the success value.
    */
-  public boolean forall(final F<T, Boolean> f) {
+  public final boolean forall(final F<T, Boolean> f) {
     return e.right().forall(f);
   }
 
@@ -254,17 +254,17 @@ public boolean forall(final F<T, Boolean> f) {
    * @return <code>false</code> if this is a failure or returns the result of the application of the given
    *         function to the success value.
    */
-  public boolean exists(final F<T, Boolean> f) {
+  public final boolean exists(final F<T, Boolean> f) {
     return e.right().exists(f);
   }
 
   @Override
-  public boolean equals(Object other) {
+  public final boolean equals(Object other) {
     return Equal.equals0(Validation.class, this, other, () -> Equal.validationEqual(Equal.anyEqual(), Equal.anyEqual()));
   }
 
   @Override
-  public int hashCode() {
+  public final int hashCode() {
     return Hash.validationHash(Hash.<E>anyHash(), Hash.<T>anyHash()).hash(this);
   }
 
@@ -273,7 +273,7 @@ public int hashCode() {
    *
    * @return A single element list if this is a success value, otherwise an empty list.
    */
-  public List<T> toList() {
+  public final List<T> toList() {
     return e.right().toList();
   }
 
@@ -282,7 +282,7 @@ public List<T> toList() {
    *
    * @return The success value in <code>Some</code> if there is one, otherwise <code>None</code>.
    */
-  public Option<T> toOption() {
+  public final Option<T> toOption() {
     return e.right().toOption();
   }
 
@@ -291,7 +291,7 @@ public Option<T> toOption() {
    *
    * @return A single element array if this is a success value, otherwise an empty list.
    */
-  public Array<T> toArray() {
+  public final Array<T> toArray() {
     return e.right().toArray();
   }
 
@@ -300,7 +300,7 @@ public Array<T> toArray() {
    *
    * @return A single element stream if this is a success value, otherwise an empty list.
    */
-  public Stream<T> toStream() {
+  public final Stream<T> toStream() {
     return e.right().toStream();
   }
 
@@ -314,7 +314,7 @@ public Stream<T> toStream() {
    *         succeeding validation if both succeeded.
    */
   @SuppressWarnings("unchecked")
-  public <A> Validation<E, A> accumapply(final Semigroup<E> s, final Validation<E, F<T, A>> v) {
+  public final <A> Validation<E, A> accumapply(final Semigroup<E> s, final Validation<E, F<T, A>> v) {
     return isFail() ?
         Validation.fail(v.isFail() ?
             s.sum(v.fail(), fail()) :
@@ -334,7 +334,7 @@ public <A> Validation<E, A> accumapply(final Semigroup<E> s, final Validation<E,
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation<E, A> va, final F<T, F<A, B>> f) {
+  public final <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation<E, A> va, final F<T, F<A, B>> f) {
     return va.accumapply(s, map(f));
   }
 
@@ -348,7 +348,7 @@ public <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation<E, A> va, final F2<T, A, B> f) {
+  public final <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation<E, A> va, final F2<T, A, B> f) {
     return va.accumapply(s, map(curry(f)));
   }
 
@@ -360,7 +360,7 @@ public <A, B> Validation<E, B> accumulate(final Semigroup<E> s, final Validation
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va) {
+  public final <A> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va) {
     return accumulate(s, va, (t, a) -> unit()).f().toOption();
   }
 
@@ -375,8 +375,8 @@ public <A> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va)
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                               final Validation<E, B> vb, final F<T, F<A, F<B, C>>> f) {
+  public final <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                     final Validation<E, B> vb, final F<T, F<A, F<B, C>>> f) {
     return vb.accumapply(s, accumulate(s, va, f));
   }
 
@@ -391,8 +391,8 @@ public <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validat
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                               final Validation<E, B> vb, final F3<T, A, B, C> f) {
+  public final <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                     final Validation<E, B> vb, final F3<T, A, B, C> f) {
     return vb.accumapply(s, accumulate(s, va, curry(f)));
   }
 
@@ -405,7 +405,7 @@ public <A, B, C> Validation<E, C> accumulate(final Semigroup<E> s, final Validat
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb) {
+  public final <A, B> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb) {
     return accumulate(s, va, vb, (t, a, b) -> unit()).f().toOption();
   }
 
@@ -421,9 +421,9 @@ public <A, B> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A>
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                  final Validation<E, B> vb, final Validation<E, C> vc,
-                                                  final F<T, F<A, F<B, F<C, D>>>> f) {
+  public final <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                        final Validation<E, B> vb, final Validation<E, C> vc,
+                                                        final F<T, F<A, F<B, F<C, D>>>> f) {
     return vc.accumapply(s, accumulate(s, va, vb, f));
   }
 
@@ -439,9 +439,9 @@ public <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Vali
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                  final Validation<E, B> vb, final Validation<E, C> vc,
-                                                  final F4<T, A, B, C, D> f) {
+  public final <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                        final Validation<E, B> vb, final Validation<E, C> vc,
+                                                        final F4<T, A, B, C, D> f) {
     return vc.accumapply(s, accumulate(s, va, vb, curry(f)));
   }
 
@@ -455,8 +455,8 @@ public <A, B, C, D> Validation<E, D> accumulate(final Semigroup<E> s, final Vali
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B, C> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb,
-                                        final Validation<E, C> vc) {
+  public final <A, B, C> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb,
+                                              final Validation<E, C> vc) {
     return accumulate(s, va, vb, vc, (t, a, b, c) -> unit()).f().toOption();
   }
 
@@ -473,10 +473,10 @@ public <A, B, C> Option<E> accumulate(final Semigroup<E> s, final Validation<E,
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$> Validation<E, E$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                       final Validation<E, B> vb, final Validation<E, C> vc,
-                                                       final Validation<E, D> vd,
-                                                       final F<T, F<A, F<B, F<C, F<D, E$>>>>> f) {
+  public final <A, B, C, D, E$> Validation<E, E$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                             final Validation<E, B> vb, final Validation<E, C> vc,
+                                                             final Validation<E, D> vd,
+                                                             final F<T, F<A, F<B, F<C, F<D, E$>>>>> f) {
     return vd.accumapply(s, accumulate(s, va, vb, vc, f));
   }
 
@@ -493,9 +493,9 @@ public <A, B, C> Option<E> accumulate(final Semigroup<E> s, final Validation<E,
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$> Validation<E, E$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                       final Validation<E, B> vb, final Validation<E, C> vc,
-                                                       final Validation<E, D> vd, final F5<T, A, B, C, D, E$> f) {
+  public final <A, B, C, D, E$> Validation<E, E$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                             final Validation<E, B> vb, final Validation<E, C> vc,
+                                                             final Validation<E, D> vd, final F5<T, A, B, C, D, E$> f) {
     return vd.accumapply(s, accumulate(s, va, vb, vc, curry(f)));
   }
 
@@ -510,8 +510,8 @@ public <A, B, C> Option<E> accumulate(final Semigroup<E> s, final Validation<E,
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb,
-                                           final Validation<E, C> vc, final Validation<E, D> vd) {
+  public final <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va, final Validation<E, B> vb,
+                                                 final Validation<E, C> vc, final Validation<E, D> vd) {
     return accumulate(s, va, vb, vc, vd, (t, a, b, c, d) -> unit()).f().toOption();
   }
 
@@ -529,10 +529,10 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$> Validation<E, F$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                           final Validation<E, B> vb, final Validation<E, C> vc,
-                                                           final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                           final F<T, F<A, F<B, F<C, F<D, F<E$, F$>>>>>> f) {
+  public final <A, B, C, D, E$, F$> Validation<E, F$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                 final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                 final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                 final F<T, F<A, F<B, F<C, F<D, F<E$, F$>>>>>> f) {
     return ve.accumapply(s, accumulate(s, va, vb, vc, vd, f));
   }
 
@@ -550,10 +550,10 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$> Validation<E, F$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                           final Validation<E, B> vb, final Validation<E, C> vc,
-                                                           final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                           final F6<T, A, B, C, D, E$, F$> f) {
+  public final <A, B, C, D, E$, F$> Validation<E, F$> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                 final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                 final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                 final F6<T, A, B, C, D, E$, F$> f) {
     return ve.accumapply(s, accumulate(s, va, vb, vc, vd, curry(f)));
   }
 
@@ -569,9 +569,9 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B, C, D, E$> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                               final Validation<E, B> vb, final Validation<E, C> vc,
-                                               final Validation<E, D> vd, final Validation<E, E$> ve) {
+  public final <A, B, C, D, E$> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                     final Validation<E, B> vb, final Validation<E, C> vc,
+                                                     final Validation<E, D> vd, final Validation<E, E$> ve) {
     return accumulate(s, va, vb, vc, vd, ve, (t, a, b, c, d, e1) -> unit()).f().toOption();
   }
 
@@ -590,11 +590,11 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$, G> Validation<E, G> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                             final Validation<E, B> vb, final Validation<E, C> vc,
-                                                             final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                             final Validation<E, F$> vf,
-                                                             final F<T, F<A, F<B, F<C, F<D, F<E$, F<F$, G>>>>>>> f) {
+  public final <A, B, C, D, E$, F$, G> Validation<E, G> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                   final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                   final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                   final Validation<E, F$> vf,
+                                                                   final F<T, F<A, F<B, F<C, F<D, F<E$, F<F$, G>>>>>>> f) {
     return vf.accumapply(s, accumulate(s, va, vb, vc, vd, ve, f));
   }
 
@@ -613,11 +613,11 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$, G> Validation<E, G> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                             final Validation<E, B> vb, final Validation<E, C> vc,
-                                                             final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                             final Validation<E, F$> vf,
-                                                             final F7<T, A, B, C, D, E$, F$, G> f) {
+  public final <A, B, C, D, E$, F$, G> Validation<E, G> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                   final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                   final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                   final Validation<E, F$> vf,
+                                                                   final F7<T, A, B, C, D, E$, F$, G> f) {
     return vf.accumapply(s, accumulate(s, va, vb, vc, vd, ve, curry(f)));
   }
 
@@ -634,10 +634,10 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B, C, D, E$, F$> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                   final Validation<E, B> vb, final Validation<E, C> vc,
-                                                   final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                   final Validation<E, F$> vf) {
+  public final <A, B, C, D, E$, F$> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                         final Validation<E, B> vb, final Validation<E, C> vc,
+                                                         final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                         final Validation<E, F$> vf) {
     return accumulate(s, va, vb, vc, vd, ve, vf, (t, a, b, c, d, e1, f) -> unit()).f().toOption();
   }
 
@@ -657,11 +657,11 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$, G, H> Validation<E, H> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                                final Validation<E, B> vb, final Validation<E, C> vc,
-                                                                final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                                final Validation<E, F$> vf, final Validation<E, G> vg,
-                                                                final F<T, F<A, F<B, F<C, F<D, F<E$, F<F$, F<G, H>>>>>>>> f) {
+  public final <A, B, C, D, E$, F$, G, H> Validation<E, H> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                      final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                      final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                      final Validation<E, F$> vf, final Validation<E, G> vg,
+                                                                      final F<T, F<A, F<B, F<C, F<D, F<E$, F<F$, F<G, H>>>>>>>> f) {
     return vg.accumapply(s, accumulate(s, va, vb, vc, vd, ve, vf, f));
   }
 
@@ -681,11 +681,11 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A succeeding validation if all validations succeeded, or a failing validation with errors accumulated if
    *         one or more failed.
    */
-  public <A, B, C, D, E$, F$, G, H> Validation<E, H> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                                final Validation<E, B> vb, final Validation<E, C> vc,
-                                                                final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                                final Validation<E, F$> vf, final Validation<E, G> vg,
-                                                                final F8<T, A, B, C, D, E$, F$, G, H> f) {
+  public final <A, B, C, D, E$, F$, G, H> Validation<E, H> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                                      final Validation<E, B> vb, final Validation<E, C> vc,
+                                                                      final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                                      final Validation<E, F$> vf, final Validation<E, G> vg,
+                                                                      final F8<T, A, B, C, D, E$, F$, G, H> f) {
     return vg.accumapply(s, accumulate(s, va, vb, vc, vd, ve, vf, curry(f)));
   }
 
@@ -703,10 +703,10 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    * @return A <code>Some</code> if one or more validations failed (accumulated with the semigroup), otherwise,
    *         <code>None</code>.
    */
-  public <A, B, C, D, E$, F$, G> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
-                                                      final Validation<E, B> vb, final Validation<E, C> vc,
-                                                      final Validation<E, D> vd, final Validation<E, E$> ve,
-                                                      final Validation<E, F$> vf, final Validation<E, G> vg) {
+  public final <A, B, C, D, E$, F$, G> Option<E> accumulate(final Semigroup<E> s, final Validation<E, A> va,
+                                                            final Validation<E, B> vb, final Validation<E, C> vc,
+                                                            final Validation<E, D> vd, final Validation<E, E$> ve,
+                                                            final Validation<E, F$> vf, final Validation<E, G> vg) {
     return accumulate(s, va, vb, vc, vd, ve, vf, vg, (t, a, b, c, d, e1, f, g) -> unit()).f().toOption();
   }
 
@@ -715,12 +715,12 @@ public <A, B, C, D> Option<E> accumulate(final Semigroup<E> s, final Validation<
    *
    * @return A iterator for this validation.
    */
-  public Iterator<T> iterator() {
+  public final Iterator<T> iterator() {
     return toEither().right().iterator();
   }
 
 
-    public Validation<List<E>, T> accumulate() {
+    public final Validation<List<E>, T> accumulate() {
         if (isFail()) {
             return fail(List.single(fail()));
         } else {
@@ -728,7 +728,7 @@ public Validation<List<E>, T> accumulate() {
         }
     }
 
-    public <B> Validation<List<E>, B> accumulate(F<T, B> f) {
+    public final <B> Validation<List<E>, B> accumulate(F<T, B> f) {
         if (isFail()) {
             return fail(List.single(fail()));
         } else {
@@ -737,7 +737,7 @@ public <B> Validation<List<E>, B> accumulate(F<T, B> f) {
     }
 
 
-    public <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C> f) {
+    public final <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C> f) {
         List<E> list = List.nil();
         if (isFail()) {
             list = list.cons(fail());
@@ -754,7 +754,7 @@ public <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C>
 
 
 
-    public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validation<E, C> v3, F3<T, B, C, D> f) {
+    public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validation<E, C> v3, F3<T, B, C, D> f) {
         List<E> list = fails(list(this, v2, v3));
         if (!list.isEmpty()) {
             return fail(list);
@@ -763,7 +763,7 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
         }
     }
 
-    public <B, C, D, $E> Validation<List<E>, $E> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, F4<T, B, C, D, $E> f) {
+    public final <B, C, D, $E> Validation<List<E>, $E> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, F4<T, B, C, D, $E> f) {
         List<E> list = fails(list(this, v2, v3, v4));
         if (!list.isEmpty()) {
             return fail(list);
@@ -772,7 +772,7 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
         }
     }
 
-    public <B, C, D, $E, $F> Validation<List<E>, $F> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, F5<T, B, C, D, $E, $F> f) {
+    public final <B, C, D, $E, $F> Validation<List<E>, $F> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, F5<T, B, C, D, $E, $F> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
             return fail(list);
@@ -782,7 +782,7 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
     }
 
 
-    public <B, C, D, $E, $F, G> Validation<List<E>, G> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, F6<T, B, C, D, $E, $F, G> f) {
+    public final <B, C, D, $E, $F, G> Validation<List<E>, G> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, F6<T, B, C, D, $E, $F, G> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
             return fail(list);
@@ -791,7 +791,7 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
         }
     }
 
-    public <B, C, D, $E, $F, G, H> Validation<List<E>, H> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, F7<T, B, C, D, $E, $F, G, H> f) {
+    public final <B, C, D, $E, $F, G, H> Validation<List<E>, H> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, F7<T, B, C, D, $E, $F, G, H> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
             return fail(list);
@@ -800,7 +800,7 @@ public <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Validati
         }
     }
 
-    public <B, C, D, $E, $F, G, H, I> Validation<List<E>, I> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, Validation<E, H> v8, F8<T, B, C, D, $E, $F, G, H, I> f) {
+    public final <B, C, D, $E, $F, G, H, I> Validation<List<E>, I> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, Validation<E, H> v8, F8<T, B, C, D, $E, $F, G, H, I> f) {
         List<E> list = fails(list(this, v2, v3, v4, v5));
         if (!list.isEmpty()) {
             return fail(list);
@@ -825,31 +825,31 @@ public static <A, E> Validation<List<E>, List<A>> sequenceNonCumulative(List<Val
       }
     }
 
-    public <C> List<Validation<E, C>> traverseList(F<T, List<C>> f){
+    public final <C> List<Validation<E, C>> traverseList(F<T, List<C>> f){
         return isSuccess() ?
             f.f(success()).map(Validation::success) :
             List.iterableList(fail(e.left().value()));
     }
 
-    public <C> Stream<Validation<E, C>> traverseStream(F<T, Stream<C>> f){
+    public final <C> Stream<Validation<E, C>> traverseStream(F<T, Stream<C>> f){
         return isSuccess() ?
             f.f(success()).map(Validation::success) :
             Stream.iterableStream(fail(e.left().value()));
     }
 
-    public <C> Option<Validation<E, C>> traverseOption(F<T, Option<C>> f){
+    public final <C> Option<Validation<E, C>> traverseOption(F<T, Option<C>> f){
         return isSuccess() ?
             f.f(success()).map(Validation::success) :
             Option.some(fail(e.left().value()));
     }
 
-    public <C> IO<Validation<E, C>> traverseIO(F<T, IO<C>> f){
+    public final <C> IO<Validation<E, C>> traverseIO(F<T, IO<C>> f){
         return isSuccess() ?
             IOFunctions.map(f.f(success()), Validation::success) :
             IOFunctions.unit(fail(e.left().value()));
     }
 
-    public <C> P1<Validation<E, C>> traverseP1(F<T, P1<C>> f){
+    public final <C> P1<Validation<E, C>> traverseP1(F<T, P1<C>> f){
         return isSuccess() ?
                 f.f(success()).map(Validation::success) :
                 p(fail(e.left().value()));
@@ -1081,7 +1081,7 @@ public Iterator<E> iterator() {
    * @return A validation with its failing value in a non-empty list if there is one.
    */
   @SuppressWarnings("unchecked")
-  public Validation<NonEmptyList<E>, T> nel() {
+  public final Validation<NonEmptyList<E>, T> nel() {
     return isSuccess() ?
         Validation.success(success()) :
         Validation.fail(NonEmptyList.nel(fail()));
@@ -1283,7 +1283,7 @@ public static <A, B> P2<List<A>, List<B>> partition(List<Validation<A, B>> list)
   }
 
     @Override
-    public String toString() {
+    public final String toString() {
         return Show.validationShow(Show.<E>anyShow(), Show.<T>anyShow()).showS(this);
     }
 
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
index 415f08c2..fb552ce9 100644
--- a/core/src/main/java/fj/data/fingertrees/Digit.java
+++ b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -138,7 +138,7 @@ public final FingerTree<V, A> toTree() {
         );
     }
 
-  Option<Digit<V, A>> tail() {
+  final Option<Digit<V, A>> tail() {
     return match(
       one -> Option.none(),
       two -> Option.some(mkTree(m).one(two.values()._2())),
@@ -147,7 +147,7 @@ Option<Digit<V, A>> tail() {
     );
   }
 
-  Option<Digit<V, A>> init() {
+  final Option<Digit<V, A>> init() {
     return match(
       one -> Option.none(),
       two -> Option.some(mkTree(m).one(two.values()._1())),
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index 060e976f..f361a76a 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -33,7 +33,7 @@ public abstract class FingerTree<V, A> {
    */
   public abstract <B> B foldRight(final F<A, F<B, B>> f, final B z);
 
-    public <B> B foldRight(final F2<A, B, B> f, final B z) {
+    public final <B> B foldRight(final F2<A, B, B> f, final B z) {
         return foldRight(F2Functions.curry(f), z);
     }
 
@@ -54,7 +54,7 @@ public <B> B foldRight(final F2<A, B, B> f, final B z) {
    */
   public abstract <B> B foldLeft(final F<B, F<A, B>> f, final B z);
 
-    public <B> B foldLeft(final F2<B, A, B> f, final B z) {
+    public final <B> B foldLeft(final F2<B, A, B> f, final B z) {
         return foldLeft(F2Functions.curry(f), z);
     }
 
@@ -76,7 +76,7 @@ public <B> B foldLeft(final F2<B, A, B> f, final B z) {
    */
   public abstract <B> FingerTree<V, B> map(final F<A, B> f, final Measured<V, B> m);
 
-    public <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
+    public final <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
         FingerTree<V, A> tree = new Empty<>(m);
         return foldLeft((acc, a) -> f.f(a) ? acc.snoc(a) : acc, tree);
     }
@@ -97,7 +97,7 @@ public final boolean isEmpty() {
     return this instanceof Empty;
   }
 
-  Measured<V, A> measured() {
+  final Measured<V, A> measured() {
     return m;
   }
 
@@ -160,7 +160,7 @@ public static <V, A> MakeTree<V, A> mkTree(final Measured<V, A> m) {
    */
   public abstract A head();
 
-  public Option<A> headOption() {
+  public final Option<A> headOption() {
       return isEmpty() ? Option.none() : Option.some(head());
   }
 
diff --git a/core/src/main/java/fj/data/fingertrees/Node.java b/core/src/main/java/fj/data/fingertrees/Node.java
index 674195d7..c7e3e7a2 100644
--- a/core/src/main/java/fj/data/fingertrees/Node.java
+++ b/core/src/main/java/fj/data/fingertrees/Node.java
@@ -48,7 +48,7 @@ public final V measure() {
     return measure;
   }
 
-  Measured<V, A> measured() {
+  final Measured<V, A> measured() {
     return m;
   }
 
diff --git a/core/src/main/java/fj/data/optic/PIso.java b/core/src/main/java/fj/data/optic/PIso.java
index 4ed45ca0..7dcd0888 100644
--- a/core/src/main/java/fj/data/optic/PIso.java
+++ b/core/src/main/java/fj/data/optic/PIso.java
@@ -130,7 +130,7 @@ public final F<S, T> set(final B b) {
   }
 
   /** pair two disjoint {@link PIso} */
-  public <S1, T1, A1, B1> PIso<P2<S, S1>, P2<T, T1>, P2<A, A1>, P2<B, B1>> product(final PIso<S1, T1, A1, B1> other) {
+  public final <S1, T1, A1, B1> PIso<P2<S, S1>, P2<T, T1>, P2<A, A1>, P2<B, B1>> product(final PIso<S1, T1, A1, B1> other) {
     return pIso(
         ss1 -> P.p(get(ss1._1()), other.get(ss1._2())),
         bb1 -> P.p(reverseGet(bb1._1()), other.reverseGet(bb1._2())));
diff --git a/demo/src/main/java/fj/demo/IODemo.java b/demo/src/main/java/fj/demo/IODemo.java
index 0bc7db12..6451a46b 100644
--- a/demo/src/main/java/fj/demo/IODemo.java
+++ b/demo/src/main/java/fj/demo/IODemo.java
@@ -28,7 +28,7 @@ public static void main(String[] args) {
      * Reads from standard input until the line length is less than three
      * and prints that last line.
      */
-    public void readFirstShortLine() {
+    public final void readFirstShortLine() {
         F<LazyString, LazyString> f = lift(lines_()).andThen(l -> l.filter(s -> s.length() < 3)).andThen(unlines_());
         runSafe(interact(f));
     }
@@ -36,7 +36,7 @@ public void readFirstShortLine() {
     /**
      * Read a stream of input lazily using interact, in effect reading the first line
      */
-    public void readFirstLine() {
+    public final void readFirstLine() {
         F<LazyString, LazyString> f = lift(LazyString::lines).andThen(unlines_());
         runSafe(interact(f));
     }
@@ -45,14 +45,14 @@ public void readFirstLine() {
      * Demonstrate use of interact, just echoing the lazy string.  Reading lines is done
      * lazily, so just the first line is read.
      */
-    public void simpleInteract() {
+    public final void simpleInteract() {
         runSafe(interact(s -> s));
     }
 
     /**
      * Demonstrate that getContents returns a lazy string.
      */
-    public void getContents() {
+    public final void getContents() {
         out.println(runSafe(IOFunctions.getContents()));
     }
 
diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index 56763ce5..ef1a09cd 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -29,7 +29,7 @@ public VendingMachine(boolean lock, int things, int numCoins) {
 		 * Equals generated by Intellij
 		 */
 		@Override
-		public boolean equals(Object o) {
+		public final boolean equals(Object o) {
 			if (this == o) return true;
 			if (o == null || getClass() != o.getClass()) return false;
 
@@ -46,18 +46,18 @@ public boolean equals(Object o) {
 		 * HashCode generated by Intellij
 		 */
 		@Override
-		public int hashCode() {
+		public final int hashCode() {
 			int result = locked ? 1 : 0;
 			result = 31 * result + items;
 			result = 31 * result + coins;
 			return result;
 		}
 
-		public String toString() {
+		public final String toString() {
 			return String.format("VendingMachine(locked=%b,items=%d,coins=%d)", locked, items, coins);
 		}
 
-		VendingMachine next(Input i) {
+		final VendingMachine next(Input i) {
 			if (items == 0) {
 				return this;
 			} else if (i == COIN && !locked) {
diff --git a/demo/src/main/java/fj/demo/concurrent/Ping.java b/demo/src/main/java/fj/demo/concurrent/Ping.java
index 3ba934fb..da2efd52 100644
--- a/demo/src/main/java/fj/demo/concurrent/Ping.java
+++ b/demo/src/main/java/fj/demo/concurrent/Ping.java
@@ -33,12 +33,12 @@ public void f(final Pong pong) {
   }
 
   // Commence pinging
-  public P1<Unit> start() {
+  public final P1<Unit> start() {
     return pong.act(this);
   }
 
   // Receive a pong
-  public P1<Unit> act(final Pong p) {
+  public final P1<Unit> act(final Pong p) {
     return ping.act(p);
   }
 }
diff --git a/demo/src/main/java/fj/demo/concurrent/PingPong.java b/demo/src/main/java/fj/demo/concurrent/PingPong.java
index a9109585..d845ab32 100644
--- a/demo/src/main/java/fj/demo/concurrent/PingPong.java
+++ b/demo/src/main/java/fj/demo/concurrent/PingPong.java
@@ -51,7 +51,7 @@ public static void main(final String[] args) {
     new PingPong(Executors.newFixedThreadPool(threads), actors, pings).start();
   }
 
-  public void start() {
+  public final void start() {
     // We will use one Pong actor...
     final Pong pong = new Pong(s);
 
diff --git a/demo/src/main/java/fj/demo/concurrent/Pong.java b/demo/src/main/java/fj/demo/concurrent/Pong.java
index b0f0ad57..bc06a22d 100644
--- a/demo/src/main/java/fj/demo/concurrent/Pong.java
+++ b/demo/src/main/java/fj/demo/concurrent/Pong.java
@@ -23,7 +23,7 @@ public void f(final Ping m) {
   }
 
   // Receive a ping
-  public P1<Unit> act(final Ping ping) {
+  public final P1<Unit> act(final Ping ping) {
     return p.act(ping);
   }
 }
\ No newline at end of file
diff --git a/demo/src/main/java/fj/demo/optic/LensPerson.java b/demo/src/main/java/fj/demo/optic/LensPerson.java
index 107ef659..51f5e103 100644
--- a/demo/src/main/java/fj/demo/optic/LensPerson.java
+++ b/demo/src/main/java/fj/demo/optic/LensPerson.java
@@ -48,14 +48,14 @@ public Address(int number, String street) {
     static final Person oldPerson = new Person(oldName, oldAddress);
 
     @Test
-    public void get() {
+    public final void get() {
         assertTrue(personNameLens.get(oldPerson).equals(oldName));
         assertTrue(personNumberLens.get(oldPerson) == oldNumber);
         assertTrue(personStreetLens.get(oldPerson) == oldStreet);
     }
 
     @Test
-    public void setName() {
+    public final void setName() {
         String newName = "Bill";
         Person p = personNameLens.set(newName).f(oldPerson);
         assertTrue(p.name.equals(newName));
@@ -63,7 +63,7 @@ public void setName() {
     }
 
     @Test
-    public void setNumber() {
+    public final void setNumber() {
         int newNumber = 20;
         Person p = personNumberLens.set(newNumber).f(oldPerson);
         assertTrue(p.name.equals(oldName));
@@ -72,7 +72,7 @@ public void setNumber() {
     }
 
     @Test
-    public void setStreet() {
+    public final void setStreet() {
         String newStreet = "First St";
         Person p = personStreetLens.set(newStreet).f(oldPerson);
         assertTrue(p.name.equals(oldName));
diff --git a/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java b/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
index 7f2b04ce..876dbff1 100644
--- a/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
+++ b/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
@@ -29,14 +29,14 @@ public PropertyTestRunner(Class<?> clas) {
   }
 
   @Override
-  public Description getDescription() {
+  public final Description getDescription() {
     Description suite = Description.createSuiteDescription(clas);
     filteredTests.foreachDoEffect(p -> suite.addChild(p._3()));
     return suite;
   }
 
   @Override
-  public void run(RunNotifier notifier) {
+  public final void run(RunNotifier notifier) {
     filteredTests.foreachDoEffect(p -> {
       Description desc = p._3();
       notifier.fireTestStarted(desc);
@@ -66,7 +66,7 @@ private static CheckResult checkProperty(Property prop, Option<CheckParams> para
   }
 
   @Override
-  public void filter(Filter filter) throws NoTestsRemainException {
+  public final void filter(Filter filter) throws NoTestsRemainException {
     filteredTests = allTests.filter(p -> filter.shouldRun(p._3()));
     if (filteredTests.isEmpty()) { throw new NoTestsRemainException(); }
   }

From e47222746840562302f28d9e7eea788d8d6e23e9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:42:59 +0100
Subject: [PATCH 059/336] Avoid potential static initialization deadlock with
 HNil singleton

---
 core/src/main/java/fj/data/hlist/HList.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/data/hlist/HList.java b/core/src/main/java/fj/data/hlist/HList.java
index 639c9e64..8e9b5389 100644
--- a/core/src/main/java/fj/data/hlist/HList.java
+++ b/core/src/main/java/fj/data/hlist/HList.java
@@ -28,15 +28,13 @@ public abstract class HList<A extends HList<A>> {
 
   public abstract <E> Apply<Unit, P2<E, A>, HCons<E, A>> extender();
 
-  private static final HNil nil = new HNil();
-
   /**
    * Returns the empty list.
    *
    * @return the empty list.
    */
   public static HNil nil() {
-    return nil;
+    return HNil.nil;
   }
 
   /**
@@ -285,7 +283,10 @@ public <X> HCons<X, HCons<E, L>> extend(final X e) {
    * The empty list
    */
   public static final class HNil extends HList<HNil> {
-    HNil() {
+
+    private static final HNil nil = new HNil();
+
+    private HNil() {
     }
 
     public <E> HCons<E, HNil> extend(final E e) {

From c0caae8e7fa5652c21a14a68bb1dc0b3efee3a59 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:46:58 +0100
Subject: [PATCH 060/336] Trampoline#codense should be private

---
 core/src/main/java/fj/control/Trampoline.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index bd69ae7a..b47a5ea7 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -107,7 +107,7 @@ public Either<P1<Trampoline<A>>, A> resume() {
   }
 
   @SuppressWarnings("unchecked")
-  protected static <A, B> Codense<B> codense(final Normal<A> a, final F<A, Trampoline<B>> k) {
+  private static <A, B> Codense<B> codense(final Normal<A> a, final F<A, Trampoline<B>> k) {
     return new Codense<>((Normal<Object>) a, (F<Object, Trampoline<B>>) k);
   }
 

From 5345f6ffea3054f97ac9690bce57952d9da3fb27 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:53:33 +0100
Subject: [PATCH 061/336] Male Either projections _static_ inner classes.

---
 core/src/main/java/fj/data/Either.java | 90 +++++++++++++-------------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 77dea3c3..a4f0fc02 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -145,7 +145,7 @@ public boolean isRight() {
   /**
    * A left projection of an either value.
    */
-  public final class LeftProjection<A, B> implements Iterable<A> {
+  public static final class LeftProjection<A, B> implements Iterable<A> {
     private final Either<A, B> e;
 
     private LeftProjection(final Either<A, B> e) {
@@ -210,7 +210,7 @@ public A value() {
      * @return The value of this projection or the given argument.
      */
     public A orValue(final F0<A> a) {
-      return isLeft() ? value() : a.f();
+      return e.isLeft() ? value() : a.f();
     }
 
     /**
@@ -220,7 +220,7 @@ public A orValue(final F0<A> a) {
      * @return The value of this projection or the given argument.
      */
     public A orValue(final A a) {
-      return isLeft() ? value() : a;
+      return e.isLeft() ? value() : a;
     }
 
     /**
@@ -232,7 +232,7 @@ public A orValue(final A a) {
      *         value.
      */
     public A on(final F<B, A> f) {
-      return isLeft() ? value() : f.f(e.right().value());
+      return e.isLeft() ? value() : f.f(e.right().value());
     }
 
     /**
@@ -242,7 +242,7 @@ public A on(final F<B, A> f) {
      * @return The unit value.
      */
     public Unit foreach(final F<A, Unit> f) {
-      if (isLeft())
+      if (e.isLeft())
         f.f(value());
 
       return unit();
@@ -254,7 +254,7 @@ public Unit foreach(final F<A, Unit> f) {
      * @param f The side-effect to execute.
      */
     public void foreachDoEffect(final Effect1<A> f) {
-      if (isLeft())
+      if (e.isLeft())
         f.f(value());
     }
 
@@ -265,7 +265,7 @@ public void foreachDoEffect(final Effect1<A> f) {
      * @return A new either value after mapping.
      */
     public <X> Either<X, B> map(final F<A, X> f) {
-      return isLeft() ? new Left<>(f.f(value())) : new Right<>(e.right().value());
+      return e.isLeft() ? new Left<>(f.f(value())) : new Right<>(e.right().value());
     }
 
     /**
@@ -275,7 +275,7 @@ public <X> Either<X, B> map(final F<A, X> f) {
      * @return A new either value after binding.
      */
     public <X> Either<X, B> bind(final F<A, Either<X, B>> f) {
-      return isLeft() ? f.f(value()) : new Right<>(e.right().value());
+      return e.isLeft() ? f.f(value()) : new Right<>(e.right().value());
     }
 
     /**
@@ -295,9 +295,9 @@ public <X> Either<X, B> sequence(final Either<X, B> e) {
        * @return An either after traversing through this projection.
        */
       public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
-          return isLeft() ?
+          return e.isLeft() ?
                   f.f(value()).map(Either::<C, B>left) :
-                  list(Either.right(e.right().value()));
+                  list(right(e.right().value()));
       }
 
       /**
@@ -307,7 +307,7 @@ public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
        * @return An either after traversing through this projection.
        */
       public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   IOFunctions.map(f.f(value()), Either::<C, B>left) :
                   IOFunctions.unit(Either.right(e.right().value()));
       }
@@ -321,9 +321,9 @@ public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
      *         <code>p</code> does not hold for the value, otherwise, returns a right in <code>Some</code>.
      */
     public <X> Option<Either<A, X>> filter(final F<A, Boolean> f) {
-      return isLeft() ?
+      return e.isLeft() ?
              f.f(value()) ?
-             Option.some(new Left<>(value())) :
+             some(new Left<>(value())) :
              Option.none() :
              Option.none();
     }
@@ -347,7 +347,7 @@ public <X> Either<X, B> apply(final Either<F<A, X>, B> e) {
      *         function to the value.
      */
     public boolean forall(final F<A, Boolean> f) {
-      return isRight() || f.f(value());
+      return e.isRight() || f.f(value());
     }
 
     /**
@@ -359,7 +359,7 @@ public boolean forall(final F<A, Boolean> f) {
      *         function to the value.
      */
     public boolean exists(final F<A, Boolean> f) {
-      return isLeft() && f.f(value());
+      return e.isLeft() && f.f(value());
     }
 
     /**
@@ -368,7 +368,7 @@ public boolean exists(final F<A, Boolean> f) {
      * @return A single element list if this projection has a value, otherwise an empty list.
      */
     public List<A> toList() {
-      return isLeft() ? single(value()) : List.nil();
+      return e.isLeft() ? single(value()) : List.nil();
     }
 
     /**
@@ -379,7 +379,7 @@ public List<A> toList() {
      *         <code>None</code>.
      */
     public Option<A> toOption() {
-      return isLeft() ? some(value()) : Option.none();
+      return e.isLeft() ? some(value()) : Option.none();
     }
 
     /**
@@ -388,7 +388,7 @@ public Option<A> toOption() {
      * @return A single element array if this projection has a value, otherwise an empty array.
      */
     public Array<A> toArray() {
-      if (isLeft()) {
+      if (e.isLeft()) {
         final Object[] a = new Object[1];
         a[0] = value();
         return mkArray(a);
@@ -402,7 +402,7 @@ public Array<A> toArray() {
      * @return A single element stream if this projection has a value, otherwise an empty stream.
      */
     public Stream<A> toStream() {
-      return isLeft() ? Stream.single(value()) : Stream.nil();
+      return e.isLeft() ? Stream.single(value()) : Stream.nil();
     }
 
     /**
@@ -415,13 +415,13 @@ public Collection<A> toCollection() {
     }
 
    public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
-       return isLeft() ?
+       return e.isLeft() ?
                f.f(value()).map(Either::<C, B>left) :
                some(Either.right(e.right().value()));
    }
 
   public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
-      return isLeft() ?
+      return e.isLeft() ?
               f.f(value()).map(Either::<C, B>left) :
               Stream.single(Either.right(e.right().value()));
   }
@@ -430,7 +430,7 @@ public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
   /**
    * A right projection of an either value.
    */
-  public final class RightProjection<A, B> implements Iterable<B> {
+  public static final class RightProjection<A, B> implements Iterable<B> {
     private final Either<A, B> e;
 
     private RightProjection(final Either<A, B> e) {
@@ -485,7 +485,7 @@ public B value() {
      * @return The value of this projection or the given argument.
      */
     public B orValue(final F0<B> b) {
-      return isRight() ? value() : b.f();
+      return e.isRight() ? value() : b.f();
     }
 
     /**
@@ -497,7 +497,7 @@ public B orValue(final F0<B> b) {
      *         value.
      */
     public B on(final F<A, B> f) {
-      return isRight() ? value() : f.f(e.left().value());
+      return e.isRight() ? value() : f.f(e.left().value());
     }
 
     /**
@@ -507,7 +507,7 @@ public B on(final F<A, B> f) {
      * @return The unit value.
      */
     public Unit foreach(final F<B, Unit> f) {
-      if (isRight())
+      if (e.isRight())
         f.f(value());
 
       return unit();
@@ -519,7 +519,7 @@ public Unit foreach(final F<B, Unit> f) {
      * @param f The side-effect to execute.
      */
     public void foreachDoEffect(final Effect1<B> f) {
-      if (isRight())
+      if (e.isRight())
         f.f(value());
     }
 
@@ -530,7 +530,7 @@ public void foreachDoEffect(final Effect1<B> f) {
      * @return A new either value after mapping.
      */
     public <X> Either<A, X> map(final F<B, X> f) {
-      return isRight() ? new Right<>(f.f(value())) : new Left<>(e.left().value());
+      return e.isRight() ? new Right<>(f.f(value())) : new Left<>(e.left().value());
     }
 
     /**
@@ -540,7 +540,7 @@ public <X> Either<A, X> map(final F<B, X> f) {
      * @return A new either value after binding.
      */
     public <X> Either<A, X> bind(final F<B, Either<A, X>> f) {
-      return isRight() ? f.f(value()) : new Left<>(e.left().value());
+      return e.isRight() ? f.f(value()) : new Left<>(e.left().value());
     }
 
 
@@ -560,9 +560,9 @@ public <X> Either<A, X> sequence(final Either<A, X> e) {
        * @return An either after traversing through this projection.
     */
       public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   f.f(value()).map(Either::right) :
-                  list(Either.left(e.left().value()));
+                  list(left(e.left().value()));
       }
 
       /**
@@ -572,21 +572,21 @@ public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
        * @return An either after traversing through this projection.
        */
       public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   IOFunctions.map(f.f(value()), Either::<A, C>right) :
-                  IOFunctions.lazy(() -> Either.left(e.left().value()));
+                  IOFunctions.lazy(() -> left(e.left().value()));
       }
 
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   f.f(value()).map(Either::<A, C>right) :
-                  p(Either.left(e.left().value()));
+                  p(left(e.left().value()));
       }
 
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   f.f(value()).map(Either::<A, C>right) :
-                  some(Either.left(e.left().value()));
+                  some(left(e.left().value()));
       }
 
     /**
@@ -598,9 +598,9 @@ public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
      *         <code>p</code> does not hold for the value, otherwise, returns a left in <code>Some</code>.
      */
     public <X> Option<Either<X, B>> filter(final F<B, Boolean> f) {
-      return isRight() ?
+      return e.isRight() ?
              f.f(value()) ?
-             Option.some(new Right<X, B>(value())) :
+             some(new Right<X, B>(value())) :
              Option.none() :
              Option.none();
     }
@@ -624,7 +624,7 @@ public <X> Either<A, X> apply(final Either<A, F<B, X>> e) {
      *         function to the value.
      */
     public boolean forall(final F<B, Boolean> f) {
-      return isLeft() || f.f(value());
+      return e.isLeft() || f.f(value());
     }
 
     /**
@@ -636,7 +636,7 @@ public boolean forall(final F<B, Boolean> f) {
      *         function to the value.
      */
     public boolean exists(final F<B, Boolean> f) {
-      return isRight() && f.f(value());
+      return e.isRight() && f.f(value());
     }
 
     /**
@@ -645,7 +645,7 @@ public boolean exists(final F<B, Boolean> f) {
      * @return A single element list if this projection has a value, otherwise an empty list.
      */
     public List<B> toList() {
-      return isRight() ? single(value()) : List.nil();
+      return e.isRight() ? single(value()) : List.nil();
     }
 
     /**
@@ -656,7 +656,7 @@ public List<B> toList() {
      *         <code>None</code>.
      */
     public Option<B> toOption() {
-      return isRight() ? some(value()) : Option.none();
+      return e.isRight() ? some(value()) : Option.none();
     }
 
     /**
@@ -665,7 +665,7 @@ public Option<B> toOption() {
      * @return A single element array if this projection has a value, otherwise an empty array.
      */
     public Array<B> toArray() {
-      if (isRight()) {
+      if (e.isRight()) {
         final Object[] a = new Object[1];
         a[0] = value();
         return mkArray(a);
@@ -679,7 +679,7 @@ public Array<B> toArray() {
      * @return A single element stream if this projection has a value, otherwise an empty stream.
      */
     public Stream<B> toStream() {
-      return isRight() ? Stream.single(value()) : Stream.nil();
+      return e.isRight() ? Stream.single(value()) : Stream.nil();
     }
 
     /**
@@ -692,7 +692,7 @@ public Collection<B> toCollection() {
     }
 
       public <C> Stream<Either<A, C>> traverseStream(F<B, Stream<C>> f) {
-          return isRight() ?
+          return e.isRight() ?
                   f.f(value()).map(Either::right) :
                   Stream.single(left(e.left().value()));
 

From 345fb6c8e1be735c288c7c1bef9127b2f35aae1f Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 15:59:52 +0100
Subject: [PATCH 062/336] Remove confusing hiding of type parameter

---
 core/src/main/java/fj/data/List.java      | 4 ++--
 quickcheck/src/main/java/fj/test/Gen.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 15171e43..cfd95898 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -943,7 +943,7 @@ public final List<A> sort(final Ord<A> o) {
     else if (tail().isEmpty())
       return this;
     else {
-      final class Merge<A> {
+      final class Merge {
         List<A> merge(List<A> xs, List<A> ys, final Ord<A> o) {
           final Buffer<A> buf = empty();
 
@@ -975,7 +975,7 @@ List<A> merge(List<A> xs, List<A> ys, final Ord<A> o) {
       }
 
       final P2<List<A>, List<A>> s = splitAt(length() / 2);
-      return new Merge<A>().merge(s._1().sort(o), s._2().sort(o), o);
+      return new Merge().merge(s._1().sort(o), s._2().sort(o), o);
     }
   }
 
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 0ffed76a..24e855a8 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -409,7 +409,7 @@ public static <A> Gen<A> join(final Gen<Gen<A>> g) {
    */
   public static <A> Gen<A> frequency(final List<P2<Integer, Gen<A>>> gs) {
     final class Pick {
-      <A> Gen<A> pick(final int n, final List<P2<Integer, Gen<A>>> gs) {
+      Gen<A> pick(final int n, final List<P2<Integer, Gen<A>>> gs) {
         if(gs.isEmpty())
           return fail();
         else {
@@ -421,7 +421,7 @@ <A> Gen<A> pick(final int n, final List<P2<Integer, Gen<A>>> gs) {
 
     final F<P2<Integer, Gen<A>>, Integer> f = __1();
 
-    return choose(1, intAdditionMonoid.sumLeft(gs.map(f))).bind(i -> new Pick().pick(i, gs));
+    return choose(1, intAdditionMonoid.sumLeft(gs.map(f))).bind(i ->  new Pick().pick(i, gs));
   }
 
   /**

From d784b7f7ee1e5068d934a36a7b211e9974d53e9a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Mar 2016 16:09:45 +0100
Subject: [PATCH 063/336] unwrap redondant function application

---
 core/src/main/java/fj/control/Trampoline.java | 2 +-
 core/src/main/java/fj/data/Array.java         | 2 +-
 core/src/main/java/fj/data/IOFunctions.java   | 2 +-
 core/src/main/java/fj/data/Option.java        | 2 +-
 core/src/main/java/fj/data/State.java         | 2 +-
 core/src/main/java/fj/data/vector/V.java      | 2 +-
 quickcheck/src/main/java/fj/test/Gen.java     | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index b47a5ea7..cd477dd0 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -56,7 +56,7 @@ public Either<P1<Trampoline<A>>, A> resume() {
         // WARNING: In JDK 8, update 25 (current version) the following code is a
         // workaround for an internal JDK compiler error, likely due to
         // https:bugs.openjdk.java.net/browse/JDK-8062253.
-        F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont::f, t -> t._1().bind(cont));
+        F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont, t -> t._1().bind(cont));
         F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
         return ot.fold(f, g);
       }), o -> P.lazy(() -> cont.f(o))));
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index 75dd3c3a..b6538ba5 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -529,7 +529,7 @@ public <B, C> Array<C> bind(final Array<B> sb, final F2<A, B, C> f) {
    * @return A new array after applying the given array of functions through this array.
    */
   public <B> Array<B> apply(final Array<F<A, B>> lf) {
-    return lf.bind(f -> map(f::f));
+    return lf.bind(f -> map(f));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 1440b692..92263d09 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -417,7 +417,7 @@ public static <A> IO<Stream<A>> sequenceWhile(final Stream<IO<A>> stream, final
     }
 
     public static <A, B> IO<B> apply(IO<A> io, IO<F<A, B>> iof) {
-        return bind(iof, f -> map(io, f::f));
+        return bind(iof, f -> map(io, f));
     }
 
     public static <A, B, C> IO<C> liftM2(IO<A> ioa, IO<B> iob, F2<A, B, C> f) {
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index a74d2495..4cdb411f 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -460,7 +460,7 @@ public final <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<
    *         optional value.
    */
   public final <B> Option<B> apply(final Option<F<A, B>> of) {
-    return of.bind(f -> map(f::f));
+    return of.bind(f -> map(f));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index e0724373..3128ae6c 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -93,7 +93,7 @@ public State<S, A> withs(F<S, S> f) {
 	}
 
 	public static <S, A> State<S, A> gets(F<S, A> f) {
-		return State.<S>init().map(f::f);
+		return State.<S>init().map(f);
 	}
 
 	/**
diff --git a/core/src/main/java/fj/data/vector/V.java b/core/src/main/java/fj/data/vector/V.java
index 57249ac8..70d60f58 100644
--- a/core/src/main/java/fj/data/vector/V.java
+++ b/core/src/main/java/fj/data/vector/V.java
@@ -35,7 +35,7 @@ public static <A> V2<A> v(final A a1, final A a2) {
    * @return The vector-2.
    */
   public static <A> V2<A> v(final F0<A> a1, final F0<A> a2) {
-      return V2.p(P.lazy(a1::f, a2::f));
+      return V2.p(P.lazy(a1, a2));
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 24e855a8..6db7b304 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -276,7 +276,7 @@ public <B, C, D, E> Gen<E> bind(final Gen<B> gb, final Gen<C> gc, final Gen<D> g
    * @return A new generator after function application.
    */
   public <B> Gen<B> apply(final Gen<F<A, B>> gf) {
-    return gf.bind(f1 -> map(f1::f));
+    return gf.bind(f1 -> map(f1));
   }
 
   /**

From 3107a2f11f59f5b0dbf8226604e513908c210fd1 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 9 May 2016 23:19:30 +0200
Subject: [PATCH 064/336] add unit tests for IOFunctions#bracket

---
 .../test/java/fj/data/IOFunctionsTest.java    | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 core/src/test/java/fj/data/IOFunctionsTest.java

diff --git a/core/src/test/java/fj/data/IOFunctionsTest.java b/core/src/test/java/fj/data/IOFunctionsTest.java
new file mode 100644
index 00000000..dcafc221
--- /dev/null
+++ b/core/src/test/java/fj/data/IOFunctionsTest.java
@@ -0,0 +1,64 @@
+package fj.data;
+
+import fj.Unit;
+import org.hamcrest.core.Is;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.*;
+import java.io.Reader;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.junit.Assert.*;
+
+public class IOFunctionsTest {
+
+  @Test
+  public void bracket_happy_path() throws Exception {
+    AtomicBoolean closed = new AtomicBoolean();
+    Reader reader = new StringReader("Read OK") {
+      @Override
+      public void close() {
+        super.close();
+        closed.set(true);
+      }
+    };
+
+    IO<String> bracketed = IOFunctions.bracket(
+        () -> reader,
+        IOFunctions.closeReader,
+        r -> () -> new BufferedReader(r).readLine()
+    );
+
+    Assert.assertThat(bracketed.run(), Is.is("Read OK"));
+    Assert.assertThat(closed.get(), Is.is(true));
+  }
+
+  @Test
+  public void bracket_exception_path() throws Exception {
+    AtomicBoolean closed = new AtomicBoolean();
+    Reader reader = new StringReader("Read OK") {
+      @Override
+      public void close() {
+        super.close();
+        closed.set(true);
+        throw new IllegalStateException("Should be suppressed");
+      }
+    };
+
+    IO<String> bracketed = IOFunctions.bracket(
+        () -> reader,
+        IOFunctions.closeReader,
+        r -> () -> {throw new IllegalArgumentException("OoO");}
+    );
+
+    try {
+      bracketed.run();
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      Assert.assertThat(e.getMessage(), Is.is("OoO"));
+    }
+    Assert.assertThat(closed.get(), Is.is(true));
+  }
+
+}
\ No newline at end of file

From 30da36c20aabfc09b2335f227683bc74d725bab4 Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Fri, 13 May 2016 23:08:44 +1000
Subject: [PATCH 065/336] Add "dual" methods on Semigroup and Monoid

---
 core/src/main/java/fj/Monoid.java    | 8 ++++++++
 core/src/main/java/fj/Semigroup.java | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index af6d95f9..a7f3106f 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -11,6 +11,7 @@
 import fj.data.Set;
 import fj.data.Stream;
 
+import static fj.Function.flip;
 import static fj.Semigroup.multiply1p;
 import static fj.data.Stream.iterableStream;
 
@@ -191,6 +192,13 @@ public A join(final Iterable<A> as, final A a) {
            s.foldLeft1(Function.compose(sum, flip(sum).f(a)));
   }
 
+  /**
+   * Swaps the arguments when summing.
+   */
+  public Monoid<A> dual() {
+    return monoid(flip(sum), zero);
+  }
+
   /**
    * Constructs a monoid from the given sum function and zero value, which must follow the monoidal
    * laws.
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 057596f5..0aa4e810 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -14,6 +14,7 @@
 import java.math.BigInteger;
 
 import static fj.Function.curry;
+import static fj.Function.flip;
 
 /**
  * Implementations must satisfy the law of associativity:
@@ -97,6 +98,13 @@ static <A> A multiply1p(F<A, F<A, A>> sum, int n, A a) {
   }
 
   /**
+  /**
+   * Swaps the arguments when summing.
+   */
+  public Semigroup<A> dual() {
+    return semigroup(flip(sum));
+  }
+
    * Constructs a semigroup from the given function.
    *
    * @param sum The function to construct this semigroup with.

From e3bf1253bfc7dc10bbd86b0dad9bcf24d5f7912f Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Mon, 16 May 2016 18:46:59 +1000
Subject: [PATCH 066/336] Add min and max Semigroup instances for Ords

---
 core/src/main/java/fj/Ord.java       | 11 ++++++++++-
 core/src/main/java/fj/Semigroup.java | 20 ++++++++++----------
 2 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index bb682ad8..41b87f94 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -15,6 +15,7 @@
 import java.util.Comparator;
 
 import static fj.Function.curry;
+import static fj.Semigroup.semigroup;
 
 /**
  * Tests for ordering between two objects.
@@ -157,7 +158,15 @@ public A min(final A a1, final A a2) {
    */
   public final F<A, F<A, A>> min = curry(this::min);
 
-  public Ord<A> reverse() { return ord(Function.flip(f)); }
+  public final Semigroup<A> minSemigroup() {
+      return semigroup(this::min);
+  }
+
+  public final Semigroup<A> maxSemigroup() {
+      return semigroup(this::max);
+  }
+
+  public final Ord<A> reverse() { return ord(Function.flip(f)); }
 
   /**
    * Returns an order instance that uses the given equality test and ordering function.
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 0aa4e810..8557c02b 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -147,12 +147,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that yields the maximum of integers.
    */
-  public static final Semigroup<Integer> intMaximumSemigroup = semigroup(Ord.intOrd.max);
+  public static final Semigroup<Integer> intMaximumSemigroup = Ord.intOrd.maxSemigroup();
 
   /**
    * A semigroup that yields the minimum of integers.
    */
-  public static final Semigroup<Integer> intMinimumSemigroup = semigroup(Ord.intOrd.min);
+  public static final Semigroup<Integer> intMinimumSemigroup = Ord.intOrd.minSemigroup();
 
   /**
    * A semigroup that adds big integers.
@@ -169,12 +169,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that yields the maximum of big integers.
    */
-  public static final Semigroup<BigInteger> bigintMaximumSemigroup = semigroup(Ord.bigintOrd.max);
+  public static final Semigroup<BigInteger> bigintMaximumSemigroup = Ord.bigintOrd.maxSemigroup();
 
   /**
    * A semigroup that yields the minimum of big integers.
    */
-  public static final Semigroup<BigInteger> bigintMinimumSemigroup = semigroup(Ord.bigintOrd.min);
+  public static final Semigroup<BigInteger> bigintMinimumSemigroup = Ord.bigintOrd.minSemigroup();
 
   /**
    * A semigroup that adds big decimals.
@@ -191,12 +191,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that yields the maximum of big decimals.
    */
-  public static final Semigroup<BigDecimal> bigDecimalMaximumSemigroup = semigroup(Ord.bigdecimalOrd.max);
+  public static final Semigroup<BigDecimal> bigDecimalMaximumSemigroup = Ord.bigdecimalOrd.maxSemigroup();
 
   /**
    * A semigroup that yields the minimum of big decimals.
    */
-  public static final Semigroup<BigDecimal> bigDecimalMinimumSemigroup = semigroup(Ord.bigdecimalOrd.min);
+  public static final Semigroup<BigDecimal> bigDecimalMinimumSemigroup = Ord.bigdecimalOrd.minSemigroup();
 
   /**
    * A semigroup that multiplies natural numbers.
@@ -213,12 +213,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that yields the maximum of natural numbers.
    */
-  public static final Semigroup<Natural> naturalMaximumSemigroup = semigroup(Ord.naturalOrd.max);
+  public static final Semigroup<Natural> naturalMaximumSemigroup = Ord.naturalOrd.maxSemigroup();
 
   /**
    * A semigroup that yields the minimum of natural numbers.
    */
-  public static final Semigroup<Natural> naturalMinimumSemigroup = semigroup(Ord.naturalOrd.min);
+  public static final Semigroup<Natural> naturalMinimumSemigroup = Ord.naturalOrd.minSemigroup();
 
   /**
    * A semigroup that adds longs.
@@ -233,12 +233,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that yields the maximum of longs.
    */
-  public static final Semigroup<Long> longMaximumSemigroup = semigroup(Ord.longOrd.max);
+  public static final Semigroup<Long> longMaximumSemigroup = Ord.longOrd.maxSemigroup();
 
   /**
    * A semigroup that yields the minimum of longs.
    */
-  public static final Semigroup<Long> longMinimumSemigroup = semigroup(Ord.longOrd.min);
+  public static final Semigroup<Long> longMinimumSemigroup = Ord.longOrd.minSemigroup();
 
   /**
    * A semigroup that ORs booleans.

From 158aabf0d73fab255cb3420f25edc513102a13cd Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Mon, 16 May 2016 20:11:41 +1000
Subject: [PATCH 067/336] Add "lift" from Semigroup into an Option Monoid

---
 core/src/main/java/fj/Semigroup.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 8557c02b..6377ceae 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -105,6 +105,14 @@ public Semigroup<A> dual() {
     return semigroup(flip(sum));
   }
 
+  /**
+   * Lifts the semigroup to obtain a trivial monoid.
+   */
+  public Monoid<Option<A>> lift() {
+    return Monoid.monoid(a -> b -> Option.liftM2(sum).f(a).f(b).orElse(a).orElse(b), Option.none());
+  }
+
+  /**
    * Constructs a semigroup from the given function.
    *
    * @param sum The function to construct this semigroup with.

From 0386eb7abd644e8017aa30b1a36a1bcb5f503a68 Mon Sep 17 00:00:00 2001
From: Brian McKenna <brian@brianmckenna.org>
Date: Mon, 16 May 2016 20:13:06 +1000
Subject: [PATCH 068/336] Add sumNel for Semigroup using a NonEmptyList

---
 core/src/main/java/fj/Semigroup.java         |  6 ++++++
 core/src/main/java/fj/data/NonEmptyList.java | 21 ++++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 6377ceae..1427f0e5 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -98,6 +98,12 @@ static <A> A multiply1p(F<A, F<A, A>> sum, int n, A a) {
   }
 
   /**
+   * Sums the given values with left-fold.
+   */
+  public A sumNel(final NonEmptyList<A> as) {
+    return as.foldLeft1(sum);
+  }
+
   /**
    * Swaps the arguments when summing.
    */
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index 013b287c..db994dc0 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -6,6 +6,7 @@
 import java.util.Collection;
 import java.util.Iterator;
 
+import static fj.Function.flip;
 import static fj.Function.identity;
 import static fj.data.Option.some;
 import static fj.data.Option.somes;
@@ -87,6 +88,26 @@ public NonEmptyList<A> append(final NonEmptyList<A> as) {
     return nel(head, bb);
   }
 
+  /**
+   * Performs a right-fold reduction across this list. This function uses O(length) stack space.
+   */
+  public final A foldRight1(final F<A, F<A, A>> f) {
+    return reverse().foldLeft1(flip(f));
+  }
+
+  /**
+   * Performs a left-fold reduction across this list. This function runs in constant space.
+   */
+  public final A foldLeft1(final F<A, F<A, A>> f) {
+    A x = head;
+
+    for (List<A> xs = tail; !xs.isEmpty(); xs = xs.tail()) {
+      x = f.f(x).f(xs.head());
+    }
+
+    return x;
+  }
+
   /**
    * Maps the given function across this list.
    *

From 97b767e89e6db089c5f763971c3224b302eeb5db Mon Sep 17 00:00:00 2001
From: Clinton Selke <clinuxrulz@gmail.com>
Date: Thu, 26 May 2016 23:29:11 +1000
Subject: [PATCH 069/336] Hard memo memory reduction (#258)

* hard memo memory reduction.

Dereferences the computation allowing it to become garbage collected
once the value has been memorised.

* removed initialized
---
 core/src/main/java/fj/P1.java | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index d6809da9..1b36e0a7 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -268,19 +268,18 @@ public static <A> P1<A> memo(F0<A> f) {
 	}
 
     static class Memo<A> extends P1<A> {
-      private final P1<A> self;
-      private volatile boolean initialized;
+      private volatile P1<A> self;
       private A value;
 
       Memo(P1<A> self) { this.self = self; }
 
       @Override public final A _1() {
-        if (!initialized) {
+        if (self != null) {
           synchronized (this) {
-            if (!initialized) {
+            if (self != null) {
               A a = self._1();
               value = a;
-              initialized = true;
+              self = null;
               return a;
             }
           }

From b947a4fbd033c3d8b826d666396bf88520e4cf94 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 2 Jun 2016 22:44:40 +1000
Subject: [PATCH 070/336] Added int min, int max and ord monoid.  Added
 FingerTree empty and int max for pqueue's

---
 core/src/main/java/fj/Monoid.java                 |  8 ++++++++
 .../main/java/fj/data/fingertrees/FingerTree.java | 15 ++++++++++++---
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index a7f3106f..d9bf40b5 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -401,6 +401,10 @@ public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
     return monoid(Semigroup.ioSemigroup(ma.semigroup()), IOFunctions.unit(ma.zero()));
   }
 
+  public static final Monoid<Integer> intMaxMonoid = monoid(Semigroup.intMaximumSemigroup, Integer.MIN_VALUE);
+
+  public static final Monoid<Integer> intMinMonoid = monoid(Semigroup.intMinimumSemigroup, Integer.MAX_VALUE);
+
   /**
    * A monoid for the Unit value.
    */
@@ -416,4 +420,8 @@ public static <A> Monoid<Set<A>> setMonoid(final Ord<A> o) {
     return monoid(Semigroup.setSemigroup(), Set.empty(o));
   }
 
+  public static <A> Monoid<A> ordMonoid(Ord<A> o, A zero) {
+    return monoid(o.max, zero);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index f361a76a..c3dfbed9 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -5,6 +5,7 @@
 import fj.data.Seq;
 
 import static fj.Monoid.intAdditionMonoid;
+import static fj.Monoid.intMaxMonoid;
 
 /**
  * Provides 2-3 finger trees, a functional representation of persistent sequences supporting access to the ends in
@@ -96,8 +97,8 @@ public final <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
   public final boolean isEmpty() {
     return this instanceof Empty;
   }
-
-  final Measured<V, A> measured() {
+  
+  public final Measured<V, A> measured() {
     return m;
   }
 
@@ -225,7 +226,15 @@ public final P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean
     public abstract int length();
 
     public static <A> FingerTree<Integer, A> emptyIntAddition() {
-        return mkTree(FingerTree.<Integer, A>measured(intAdditionMonoid, Function.constant(1))).empty();
+      return empty(intAdditionMonoid, Function.constant(1));
     }
 
+  public static <V, A> FingerTree<V, A> empty(Monoid<V> m, F<A, V> f) {
+    return FingerTree.mkTree(measured(m, f)).empty();
+  }
+
+  public static <A> FingerTree<Integer, P2<Integer, A>> emptyIntMax() {
+    return empty(intMaxMonoid, (P2<Integer, A> p) -> p._1());
+  }
+
 }

From 6e5c822d64879ba2277d3808ecf4a7b6cb90b951 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 2 Jun 2016 22:47:03 +1000
Subject: [PATCH 071/336] Added show instances and toString implementations for
 finger trees

---
 core/src/main/java/fj/Show.java               | 40 +++++++++++++++++++
 .../main/java/fj/data/fingertrees/Deep.java   |  5 +++
 .../main/java/fj/data/fingertrees/Digit.java  |  3 ++
 .../main/java/fj/data/fingertrees/Empty.java  |  6 +++
 .../main/java/fj/data/fingertrees/Four.java   |  6 +++
 .../main/java/fj/data/fingertrees/Node2.java  |  6 +++
 .../main/java/fj/data/fingertrees/Node3.java  |  6 +++
 .../main/java/fj/data/fingertrees/One.java    |  5 +++
 .../main/java/fj/data/fingertrees/Single.java |  7 ++++
 .../main/java/fj/data/fingertrees/Three.java  |  6 +++
 .../main/java/fj/data/fingertrees/Two.java    |  5 +++
 .../src/main/java/fj/test/Arbitrary.java      |  1 +
 12 files changed, 96 insertions(+)

diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 4d599693..b8bed494 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -1,6 +1,8 @@
 package fj;
 
 import fj.data.*;
+import fj.data.fingertrees.FingerTree;
+import fj.data.fingertrees.Node;
 import fj.data.hlist.HList;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
@@ -301,6 +303,44 @@ public static <A> Show<Tree<A>> treeShow(final Show<A> sa) {
     });
   }
 
+  public static <V, A> Show<fj.data.fingertrees.Digit<V, A>> digitShow(final Show<V> sv, final Show<A> sa) {
+    return show(d -> {
+      String s = d.match(
+              o -> "One(" + o.measure() + " -> " + o.value() + ")",
+              two -> "Two(" + two.measure() + " -> " + v2Show(sa).showS(two.values()) + ")",
+              three -> "Three(" + three.measure() + " -> " + v3Show(sa).showS(three.values()) + ")",
+              four -> "Four(" + four.measure() + " -> " + v4Show(sa).showS(four.values()) + ")"
+      );
+      return Stream.fromString(s);
+    });
+  }
+
+  public static <V, A> Show<Node<V, A>> nodeShow(final Show<V> sv, final Show<A> sa) {
+    return show(n -> {
+      final String s = n.match(
+          n2 -> "Node2(" + n2.measure() + " -> " + v2Show(sa).showS(n2.toVector()) + ")",
+          n3 -> "Node3(" + n3.measure() + " -> " + v3Show(sa).showS(n3.toVector()) + ")");
+      return Stream.fromString(s);
+    });
+  }
+
+  public static <V, A> Show<FingerTree<V, A>> fingerTreeShow(final Show<V> sv, final Show<A> sa) {
+
+    return show(ft -> {
+      String sep = ", ";
+      String str = ft.match(e -> "Empty()",
+              s -> "Single(" + sv.showS(ft.measure()) + " -> " + sa.showS(s.value()) + ")",
+              d -> "Deep(" + d.measure() + " -> " +
+                      digitShow(sv, sa).showS(d.prefix()) + sep +
+                      fingerTreeShow(sv, nodeShow(sv, sa)).showS(d.middle()) + sep +
+                      digitShow(sv, sa).showS(d.suffix()) +
+                      ")"
+      );
+      return Stream.fromString(str);
+    });
+  }
+
+
   public static <A> Show<Seq<A>> seqShow(final Show<A> sa) {
     return show(s -> streamShow(sa, "Seq(", ",", ")").show(s.toStream()));
   }
diff --git a/core/src/main/java/fj/data/fingertrees/Deep.java b/core/src/main/java/fj/data/fingertrees/Deep.java
index ea906507..3a08c670 100644
--- a/core/src/main/java/fj/data/fingertrees/Deep.java
+++ b/core/src/main/java/fj/data/fingertrees/Deep.java
@@ -520,4 +520,9 @@ private static <V, A> FingerTree<V, Node<V, Node<V, A>>> addDigits4(final Measur
       });
     });
   }
+
+  public String toString() {
+    return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
index fb552ce9..31e7aa04 100644
--- a/core/src/main/java/fj/data/fingertrees/Digit.java
+++ b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -162,4 +162,7 @@ final Option<Digit<V, A>> init() {
 
     public abstract int length();
 
+    public String toString() {
+        return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+    }
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Empty.java b/core/src/main/java/fj/data/fingertrees/Empty.java
index 95065aef..f4f79271 100644
--- a/core/src/main/java/fj/data/fingertrees/Empty.java
+++ b/core/src/main/java/fj/data/fingertrees/Empty.java
@@ -3,6 +3,7 @@
 import fj.F;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 
 import static fj.Bottom.error;
 
@@ -81,4 +82,9 @@ public V measure() {
   @Override P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate, final V acc) {
     throw error("Splitting an empty tree");
   }
+
+  public String toString() {
+    return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Four.java b/core/src/main/java/fj/data/fingertrees/Four.java
index c66ddeca..635cb45f 100644
--- a/core/src/main/java/fj/data/fingertrees/Four.java
+++ b/core/src/main/java/fj/data/fingertrees/Four.java
@@ -3,6 +3,7 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 import fj.data.vector.V4;
 import fj.F;
@@ -88,4 +89,9 @@ public V4<A> values() {
     public int length() {
         return 4;
     }
+
+  public String toString() {
+    return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node2.java b/core/src/main/java/fj/data/fingertrees/Node2.java
index 5af121c2..4f47c7c5 100644
--- a/core/src/main/java/fj/data/fingertrees/Node2.java
+++ b/core/src/main/java/fj/data/fingertrees/Node2.java
@@ -2,6 +2,7 @@
 
 import fj.P;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 import fj.data.vector.V2;
 import fj.F;
@@ -66,4 +67,9 @@ public int length() {
     public V2<A> toVector() {
     return as;
   }
+
+  public String toString() {
+    return Show.nodeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node3.java b/core/src/main/java/fj/data/fingertrees/Node3.java
index 5eb9bf58..74a026c3 100644
--- a/core/src/main/java/fj/data/fingertrees/Node3.java
+++ b/core/src/main/java/fj/data/fingertrees/Node3.java
@@ -2,6 +2,7 @@
 
 import fj.P;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 import fj.data.vector.V3;
 import fj.F;
@@ -74,4 +75,9 @@ P3<Option<Digit<V, A>>, A, Option<Digit<V, A>>> split1(final F<V, Boolean> predi
   public V3<A> toVector() {
     return as;
   }
+
+  public String toString() {
+    return Show.nodeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/One.java b/core/src/main/java/fj/data/fingertrees/One.java
index d07cab60..098003d2 100644
--- a/core/src/main/java/fj/data/fingertrees/One.java
+++ b/core/src/main/java/fj/data/fingertrees/One.java
@@ -4,6 +4,7 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 
 import static fj.data.Option.none;
@@ -54,4 +55,8 @@ public A value() {
     public int length() {
         return 1;
     }
+
+  public String toString() {
+    return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Single.java b/core/src/main/java/fj/data/fingertrees/Single.java
index d322dcaa..951d9976 100644
--- a/core/src/main/java/fj/data/fingertrees/Single.java
+++ b/core/src/main/java/fj/data/fingertrees/Single.java
@@ -4,8 +4,10 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 
 import static fj.P.p;
+import static fj.Show.anyShow;
 
 /**
  * A tree with a single element.
@@ -99,4 +101,9 @@ public int length() {
   public A value() {
     return a;
   }
+
+  public String toString() {
+    return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Three.java b/core/src/main/java/fj/data/fingertrees/Three.java
index da9f6a9e..21a2fd2c 100644
--- a/core/src/main/java/fj/data/fingertrees/Three.java
+++ b/core/src/main/java/fj/data/fingertrees/Three.java
@@ -3,6 +3,7 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 import fj.data.vector.V3;
 import fj.F;
@@ -78,4 +79,9 @@ public V3<A> values() {
     public int length() {
         return 3;
     }
+
+  public String toString() {
+    return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Two.java b/core/src/main/java/fj/data/fingertrees/Two.java
index 3029fd9d..c88ff639 100644
--- a/core/src/main/java/fj/data/fingertrees/Two.java
+++ b/core/src/main/java/fj/data/fingertrees/Two.java
@@ -3,6 +3,7 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 import fj.data.Option;
 import fj.data.vector.V2;
 import fj.F;
@@ -70,4 +71,8 @@ public int length() {
         return 2;
     }
 
+  public String toString() {
+    return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
+  }
+
 }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index e2a00b29..19cae500 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -62,6 +62,7 @@
 
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.PriorityQueue;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;

From 45abb41b3788c0f054ecc32cd12eb1880bea9301 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 2 Jun 2016 23:15:41 +1000
Subject: [PATCH 072/336] Test show on finger trees to expose what is going on
 inside the finger tree

---
 .../fj/data/fingertrees/FingerTreeTest.java   | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 3d95d182..6ce46640 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -1,10 +1,19 @@
 package fj.data.fingertrees;
 
+import fj.Function;
+import fj.P;
+import fj.P2;
 import fj.data.List;
+import fj.data.Seq;
 import org.junit.Test;
 
+import static fj.Monoid.intAdditionMonoid;
+import static fj.Monoid.intMaxMonoid;
+import static fj.P.p;
+import static fj.data.fingertrees.FingerTree.measured;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
+import static java.lang.System.out;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
 
@@ -27,4 +36,33 @@ void validateSize(List<Integer> list) {
         assertThat(ft.length(), equalTo(list.length()));
     }
 
+    @Test
+    public void testSeqString() {
+        FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
+//        out.println(ft.toString());
+        String actual = List.range(1, 10).foldLeft(ft2 -> i -> {
+            FingerTree<Integer, Integer> ft3 = ft2.snoc(i);
+//            out.println(ft3.toString());
+            return ft3;
+        }, ft).toString();
+        String expected = "Deep(9 -> One(1 -> 1), Deep(6 -> One(3 -> Node3(3 -> V3(2,3,4))), Empty(), One(3 -> Node3(3 -> V3(5,6,7)))), Two(2 -> V2(8,9)))";
+        assertThat(actual, equalTo(expected));
+    }
+
+    @Test
+    public void testQueueString() {
+        FingerTree<Integer, P2<Integer, Integer>> ft = FingerTree.emptyIntMax();
+//        out.println(ft.toString());
+        String actual = List.range(1, 10).foldLeft(ft2 -> i -> {
+            int j = i % 2 == 0 ? 2 * i : i;
+            FingerTree<Integer, P2<Integer, Integer>> ft3 = ft2.snoc(P.p(j, j));
+//            out.println(ft3.toString());
+            return ft3;
+        }, ft).toString();
+        String expected = "Deep(16 -> One(1 -> (1,1)), Deep(12 -> One(8 -> Node3(8 -> V3((4,4),(3,3),(8,8)))), Empty(), One(12 -> Node3(12 -> V3((5,5),(12,12),(7,7))))), Two(16 -> V2((16,16),(9,9))))";
+        assertThat(actual, equalTo(expected));
+
+    }
+
+
 }

From 8321b4f61053229fdcc84ae2e1939087b9890e0a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 3 Jun 2016 22:09:08 +1000
Subject: [PATCH 073/336] Added streaming of finger trees

---
 .../main/java/fj/data/fingertrees/Deep.java   | 12 ++++
 .../main/java/fj/data/fingertrees/Digit.java  |  5 ++
 .../main/java/fj/data/fingertrees/Empty.java  |  5 ++
 .../java/fj/data/fingertrees/FingerTree.java  |  4 ++
 .../main/java/fj/data/fingertrees/Four.java   |  5 ++
 .../main/java/fj/data/fingertrees/Node.java   |  5 ++
 .../main/java/fj/data/fingertrees/Node2.java  |  5 ++
 .../main/java/fj/data/fingertrees/Node3.java  |  5 ++
 .../main/java/fj/data/fingertrees/One.java    |  6 ++
 .../main/java/fj/data/fingertrees/Single.java |  5 ++
 .../main/java/fj/data/fingertrees/Three.java  |  4 ++
 .../main/java/fj/data/fingertrees/Two.java    |  5 ++
 .../fj/data/fingertrees/FingerTreeTest.java   | 64 +++++++++++++++----
 13 files changed, 116 insertions(+), 14 deletions(-)

diff --git a/core/src/main/java/fj/data/fingertrees/Deep.java b/core/src/main/java/fj/data/fingertrees/Deep.java
index 3a08c670..f9d6eb83 100644
--- a/core/src/main/java/fj/data/fingertrees/Deep.java
+++ b/core/src/main/java/fj/data/fingertrees/Deep.java
@@ -2,6 +2,7 @@
 
 import fj.*;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
 import fj.data.vector.V4;
@@ -9,6 +10,7 @@
 import static fj.Function.constant;
 import static fj.data.List.list;
 import static fj.Function.flip;
+import static fj.data.Stream.nil;
 
 /**
  * A finger tree with 1-4-digits on the left and right, and a finger tree of 2-3-nodes in the middle.
@@ -525,4 +527,14 @@ public String toString() {
     return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return prefix().toStream().append(() ->
+            middle().match(
+                    e -> Stream.<A>nil(),
+                    s -> s.value().toStream(),
+                    d -> d.toStream().bind(p -> p.toStream())
+            )
+    ).append(() -> suffix.toStream());
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Digit.java b/core/src/main/java/fj/data/fingertrees/Digit.java
index 31e7aa04..fe76d1df 100644
--- a/core/src/main/java/fj/data/fingertrees/Digit.java
+++ b/core/src/main/java/fj/data/fingertrees/Digit.java
@@ -2,6 +2,7 @@
 
 import fj.*;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
 import fj.data.vector.V4;
@@ -165,4 +166,8 @@ final Option<Digit<V, A>> init() {
     public String toString() {
         return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
     }
+
+    public abstract Stream<A> toStream();
+
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Empty.java b/core/src/main/java/fj/data/fingertrees/Empty.java
index f4f79271..275b1cec 100644
--- a/core/src/main/java/fj/data/fingertrees/Empty.java
+++ b/core/src/main/java/fj/data/fingertrees/Empty.java
@@ -4,6 +4,7 @@
 import fj.P2;
 import fj.P3;
 import fj.Show;
+import fj.data.Stream;
 
 import static fj.Bottom.error;
 
@@ -87,4 +88,8 @@ public String toString() {
     return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return Stream.nil();
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index c3dfbed9..aa72f020 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -3,9 +3,11 @@
 import fj.*;
 import fj.data.Option;
 import fj.data.Seq;
+import fj.data.Stream;
 
 import static fj.Monoid.intAdditionMonoid;
 import static fj.Monoid.intMaxMonoid;
+import static fj.data.Stream.nil;
 
 /**
  * Provides 2-3 finger trees, a functional representation of persistent sequences supporting access to the ends in
@@ -237,4 +239,6 @@ public static <A> FingerTree<Integer, P2<Integer, A>> emptyIntMax() {
     return empty(intMaxMonoid, (P2<Integer, A> p) -> p._1());
   }
 
+  public abstract Stream<A> toStream();
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Four.java b/core/src/main/java/fj/data/fingertrees/Four.java
index 635cb45f..31a40d72 100644
--- a/core/src/main/java/fj/data/fingertrees/Four.java
+++ b/core/src/main/java/fj/data/fingertrees/Four.java
@@ -5,6 +5,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V4;
 import fj.F;
 
@@ -94,4 +95,8 @@ public String toString() {
     return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return values().toStream();
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node.java b/core/src/main/java/fj/data/fingertrees/Node.java
index c7e3e7a2..ff98b337 100644
--- a/core/src/main/java/fj/data/fingertrees/Node.java
+++ b/core/src/main/java/fj/data/fingertrees/Node.java
@@ -1,9 +1,11 @@
 package fj.data.fingertrees;
 
 import fj.F;
+import fj.P;
 import fj.P2;
 import fj.P3;
 import fj.data.Option;
+import fj.data.Stream;
 
 import static fj.Function.curry;
 
@@ -59,4 +61,7 @@ final Measured<V, A> measured() {
   public abstract <B> B match(final F<Node2<V, A>, B> n2, final F<Node3<V, A>, B> n3);
 
   public abstract int length();
+
+  public abstract Stream<A> toStream();
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node2.java b/core/src/main/java/fj/data/fingertrees/Node2.java
index 4f47c7c5..56e668e7 100644
--- a/core/src/main/java/fj/data/fingertrees/Node2.java
+++ b/core/src/main/java/fj/data/fingertrees/Node2.java
@@ -4,6 +4,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V2;
 import fj.F;
 import fj.P2;
@@ -72,4 +73,8 @@ public String toString() {
     return Show.nodeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return as.toStream();
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Node3.java b/core/src/main/java/fj/data/fingertrees/Node3.java
index 74a026c3..c803239f 100644
--- a/core/src/main/java/fj/data/fingertrees/Node3.java
+++ b/core/src/main/java/fj/data/fingertrees/Node3.java
@@ -4,6 +4,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V3;
 import fj.F;
 import fj.P2;
@@ -80,4 +81,8 @@ public String toString() {
     return Show.nodeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return as.toStream();
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/One.java b/core/src/main/java/fj/data/fingertrees/One.java
index 098003d2..f3711ace 100644
--- a/core/src/main/java/fj/data/fingertrees/One.java
+++ b/core/src/main/java/fj/data/fingertrees/One.java
@@ -6,6 +6,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 
 import static fj.data.Option.none;
 
@@ -59,4 +60,9 @@ public int length() {
   public String toString() {
     return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
+
+  public Stream<A> toStream() {
+    return Stream.single(a);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Single.java b/core/src/main/java/fj/data/fingertrees/Single.java
index 951d9976..57ea0897 100644
--- a/core/src/main/java/fj/data/fingertrees/Single.java
+++ b/core/src/main/java/fj/data/fingertrees/Single.java
@@ -5,6 +5,7 @@
 import fj.P2;
 import fj.P3;
 import fj.Show;
+import fj.data.Stream;
 
 import static fj.P.p;
 import static fj.Show.anyShow;
@@ -106,4 +107,8 @@ public String toString() {
     return Show.fingerTreeShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return Stream.single(a);
+  }
+
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Three.java b/core/src/main/java/fj/data/fingertrees/Three.java
index 21a2fd2c..2db896b3 100644
--- a/core/src/main/java/fj/data/fingertrees/Three.java
+++ b/core/src/main/java/fj/data/fingertrees/Three.java
@@ -5,6 +5,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V3;
 import fj.F;
 
@@ -83,5 +84,8 @@ public int length() {
   public String toString() {
     return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
+  public Stream<A> toStream() {
+    return values().toStream();
+  }
 
 }
diff --git a/core/src/main/java/fj/data/fingertrees/Two.java b/core/src/main/java/fj/data/fingertrees/Two.java
index c88ff639..cb8a2162 100644
--- a/core/src/main/java/fj/data/fingertrees/Two.java
+++ b/core/src/main/java/fj/data/fingertrees/Two.java
@@ -5,6 +5,7 @@
 import fj.P3;
 import fj.Show;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.vector.V2;
 import fj.F;
 
@@ -75,4 +76,8 @@ public String toString() {
     return Show.digitShow(Show.<V>anyShow(), Show.<A>anyShow()).showS(this);
   }
 
+  public Stream<A> toStream() {
+    return values().toStream();
+  }
+
 }
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 6ce46640..901c9c89 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -1,16 +1,14 @@
 package fj.data.fingertrees;
 
-import fj.Function;
 import fj.P;
 import fj.P2;
+import fj.Show;
 import fj.data.List;
-import fj.data.Seq;
+import fj.data.Stream;
 import org.junit.Test;
 
-import static fj.Monoid.intAdditionMonoid;
-import static fj.Monoid.intMaxMonoid;
 import static fj.P.p;
-import static fj.data.fingertrees.FingerTree.measured;
+import static fj.Show.intShow;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static java.lang.System.out;
@@ -36,33 +34,71 @@ void validateSize(List<Integer> list) {
         assertThat(ft.length(), equalTo(list.length()));
     }
 
-    @Test
-    public void testSeqString() {
+    public FingerTree<Integer, Integer> midSeq() {
         FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
-//        out.println(ft.toString());
-        String actual = List.range(1, 10).foldLeft(ft2 -> i -> {
+        //        out.println(ft.toString());
+        return List.range(1, 10).foldLeft(ft2 -> i -> {
             FingerTree<Integer, Integer> ft3 = ft2.snoc(i);
 //            out.println(ft3.toString());
             return ft3;
-        }, ft).toString();
+        }, ft);
+    }
+
+
+
+    @Test
+    public void testSeqString() {
+//        FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
+//        out.println(ft.toString());
+        String actual = midSeq().toString();
         String expected = "Deep(9 -> One(1 -> 1), Deep(6 -> One(3 -> Node3(3 -> V3(2,3,4))), Empty(), One(3 -> Node3(3 -> V3(5,6,7)))), Two(2 -> V2(8,9)))";
         assertThat(actual, equalTo(expected));
     }
 
-    @Test
-    public void testQueueString() {
+    public FingerTree<Integer, P2<Integer, Integer>> midPriorityQueue() {
         FingerTree<Integer, P2<Integer, Integer>> ft = FingerTree.emptyIntMax();
 //        out.println(ft.toString());
-        String actual = List.range(1, 10).foldLeft(ft2 -> i -> {
+        return List.range(1, 10).foldLeft(ft2 -> i -> {
             int j = i % 2 == 0 ? 2 * i : i;
             FingerTree<Integer, P2<Integer, Integer>> ft3 = ft2.snoc(P.p(j, j));
 //            out.println(ft3.toString());
             return ft3;
-        }, ft).toString();
+        }, ft);
+    }
+
+    @Test
+    public void testQueueString() {
+//        FingerTree<Integer, P2<Integer, Integer>> ft = FingerTree.emptyIntMax();
+//        out.println(ft.toString());
+        String actual = midPriorityQueue().toString();
         String expected = "Deep(16 -> One(1 -> (1,1)), Deep(12 -> One(8 -> Node3(8 -> V3((4,4),(3,3),(8,8)))), Empty(), One(12 -> Node3(12 -> V3((5,5),(12,12),(7,7))))), Two(16 -> V2((16,16),(9,9))))";
         assertThat(actual, equalTo(expected));
 
     }
 
+    @Test
+    public void stream() {
+        FingerTree<Integer, Integer> ft = midSeq();
+        out.println(ft);
+        Stream<Integer> s = ft.toStream();
+        System.out.println(s.toList());
+
+        out.println(midPriorityQueue());
+        out.println(midPriorityQueue().toStream().toList());
+    }
+
+    @Test
+    public void split() {
+
+        FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
+        FingerTree<Integer, Integer> ft3 = List.range(1, 10).foldLeft(ft2 -> i -> ft2.snoc(i), ft);
+        P2<FingerTree<Integer, Integer>, FingerTree<Integer, Integer>> p = ft3.split(v -> v >= 3);
+        Show<FingerTree<Integer, Integer>> fts = Show.fingerTreeShow(intShow, intShow);
+        Show<P2<FingerTree<Integer, Integer>, FingerTree<Integer, Integer>>> s = Show.p2Show(fts, fts);
+        System.out.println(s.showS(p));
+        System.out.println(p);
+
+
+    }
 
 }

From a20a86ee841721b0e916d757e31a9c0409dad843 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 3 Jun 2016 22:25:57 +1000
Subject: [PATCH 074/336] Initial implementation of priority queue based on
 finger trees

---
 core/src/main/java/fj/data/PriorityQueue.java | 81 +++++++++++++++++++
 .../test/java/fj/data/PriorityQueueTest.java  | 30 +++++++
 2 files changed, 111 insertions(+)
 create mode 100644 core/src/main/java/fj/data/PriorityQueue.java
 create mode 100644 core/src/test/java/fj/data/PriorityQueueTest.java

diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
new file mode 100644
index 00000000..35188120
--- /dev/null
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -0,0 +1,81 @@
+package fj.data;
+
+import fj.Equal;
+import fj.F;
+import fj.Monoid;
+import fj.P;
+import fj.P2;
+import fj.P3;
+import fj.data.fingertrees.FingerTree;
+
+/**
+ * Created by MarkPerry on 31 May 16.
+ */
+public class PriorityQueue<K, A> {
+
+    private final FingerTree<K, P2<K, A>> ftree;
+    private final Equal<K> equal;
+
+    private PriorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
+        equal = e;
+        ftree = ft;
+    }
+
+    public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
+        return new PriorityQueue<K, A>(e, ft);
+    }
+
+    public static <K, A> PriorityQueue<K, A> empty(Monoid<K> m, Equal<K> e) {
+        return priorityQueue(e, FingerTree.empty(m, (P2<K, A> p) -> p._1()));
+    }
+
+    public static <A> PriorityQueue<Integer, A> emptyInt() {
+        return priorityQueue(Equal.intEqual, FingerTree.empty(Monoid.intMaxMonoid, (P2<Integer, A> p) -> p._1()));
+    }
+
+    public <B> PriorityQueue<K, B> map(F<A, B> f) {
+        return priorityQueue(equal,
+                ftree.map(p2 -> p2.map2(a -> f.f(a)),
+                FingerTree.measured(ftree.measured().monoid(), (P2<K, B> p2) -> p2._1()))
+        );
+    }
+
+    public PriorityQueue<K, A> filter(F<A, Boolean> f) {
+        return priorityQueue(equal, ftree.filter(p2 -> f.f(p2._2())));
+    }
+
+    public boolean isEmpty() {
+        return ftree.isEmpty();
+    }
+
+    public Option<P2<K, A>> top() {
+        K top = ftree.measure();
+        P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(top, k));
+        return p._2().headOption();
+    }
+
+    public PriorityQueue<K, A> enqueue(K k, A a) {
+        return priorityQueue(equal, ftree.cons(P.p(k, a)));
+    }
+
+    public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
+        return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);
+    }
+
+    public PriorityQueue<K, A> dequeue() {
+        K top = ftree.measure();
+        P3<FingerTree<K, P2<K, A>>, P2<K, A>, FingerTree<K, P2<K, A>>> p = ftree.split1(k -> equal.eq(k, top));
+        return priorityQueue(equal, p._1().append(p._3()));
+    }
+
+    public PriorityQueue<K, A> dequeue(int n) {
+        int i = n;
+        PriorityQueue<K, A> result = this;
+        while (i > 0) {
+            i--;
+            result = result.dequeue();
+        }
+        return result;
+    }
+
+}
diff --git a/core/src/test/java/fj/data/PriorityQueueTest.java b/core/src/test/java/fj/data/PriorityQueueTest.java
new file mode 100644
index 00000000..1943d2ca
--- /dev/null
+++ b/core/src/test/java/fj/data/PriorityQueueTest.java
@@ -0,0 +1,30 @@
+package fj.data;
+
+import fj.Equal;
+import fj.Monoid;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static fj.P.p;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by MarkPerry on 1 Jun 16.
+ */
+public class PriorityQueueTest {
+
+    @Test
+    public void test1() {
+        PriorityQueue<Integer, Integer> pq = PriorityQueue.<Integer>emptyInt();
+        PriorityQueue<Integer, Integer> pq2 = pq.enqueue(List.list(p(1, 1)));
+        System.out.println(pq2.toString());
+    }
+
+    @Test
+    public void empty() {
+        PriorityQueue<Integer, Integer> pq = PriorityQueue.<Integer>emptyInt();
+        assertThat(pq.isEmpty(), is(true));
+    }
+
+}

From d630f99b1e881aa1e511b0a7d9418d12c3fea154 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 4 Jun 2016 23:00:33 +1000
Subject: [PATCH 075/336] Added priority queue show, toStream, toString.  Fixed
 enqueue and dequeue

---
 core/src/main/java/fj/Show.java               |  8 ++++-
 core/src/main/java/fj/data/PriorityQueue.java | 16 +++++++--
 .../test/java/fj/data/PriorityQueueTest.java  | 33 ++++++++++++++++---
 3 files changed, 49 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index b8bed494..9e55a1d6 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -377,7 +377,7 @@ public static <K, V> Show<TreeMap<K, V>> treeMapShow(final Show<K> sk, final Sho
    * @return A show instance for the {@link P2 tuple-2} type.
    */
   public static <A, B> Show<P2<A, B>> p2MapShow(final Show<A> sa, final Show<B> sb) {
-    return p2Show(sa, sb, "(", ":", ")");
+    return p2Show(sa, sb, "(", ": ", ")");
   }
 
   /**
@@ -590,6 +590,12 @@ public static <A, B, C, D, E> Show<P5<A, B, C, D, E>> p5Show(final Show<A> sa, f
         .append(sg.show(p._7())).snoc(',').append(sh.show(p._8())).snoc(')'));
   }
 
+  public static <K, V> Show<PriorityQueue<K, V>> priorityQueueShow(Show<K> sk, Show<V> sv) {
+    return show(pq -> {
+      return streamShow(p2MapShow(sk, sv), "PriorityQueue(", ", ", ")").show(pq.toStream());
+    });
+  }
+
   /**
    * A show instance for a vector-2.
    *
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 35188120..67abdb88 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -6,6 +6,7 @@
 import fj.P;
 import fj.P2;
 import fj.P3;
+import fj.Show;
 import fj.data.fingertrees.FingerTree;
 
 /**
@@ -55,7 +56,7 @@ public Option<P2<K, A>> top() {
     }
 
     public PriorityQueue<K, A> enqueue(K k, A a) {
-        return priorityQueue(equal, ftree.cons(P.p(k, a)));
+        return priorityQueue(equal, ftree.snoc(P.p(k, a)));
     }
 
     public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
@@ -64,8 +65,9 @@ public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
 
     public PriorityQueue<K, A> dequeue() {
         K top = ftree.measure();
-        P3<FingerTree<K, P2<K, A>>, P2<K, A>, FingerTree<K, P2<K, A>>> p = ftree.split1(k -> equal.eq(k, top));
-        return priorityQueue(equal, p._1().append(p._3()));
+        P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(k, top));
+        FingerTree<K, P2<K, A>> right = p._2();
+        return right.isEmpty() ? this : priorityQueue(equal, p._1().append(right.tail()));
     }
 
     public PriorityQueue<K, A> dequeue(int n) {
@@ -78,4 +80,12 @@ public PriorityQueue<K, A> dequeue(int n) {
         return result;
     }
 
+    public Stream<P2<K, A>> toStream() {
+        return ftree.toStream();
+    }
+
+    public String toString() {
+        return Show.priorityQueueShow(Show.<K>anyShow(), Show.<A>anyShow()).showS(this);
+    }
+
 }
diff --git a/core/src/test/java/fj/data/PriorityQueueTest.java b/core/src/test/java/fj/data/PriorityQueueTest.java
index 1943d2ca..7e30cfc5 100644
--- a/core/src/test/java/fj/data/PriorityQueueTest.java
+++ b/core/src/test/java/fj/data/PriorityQueueTest.java
@@ -1,11 +1,11 @@
 package fj.data;
 
-import fj.Equal;
-import fj.Monoid;
-import org.junit.Assert;
+import fj.P2;
 import org.junit.Test;
 
 import static fj.P.p;
+import static java.lang.System.out;
+import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
@@ -18,7 +18,7 @@ public class PriorityQueueTest {
     public void test1() {
         PriorityQueue<Integer, Integer> pq = PriorityQueue.<Integer>emptyInt();
         PriorityQueue<Integer, Integer> pq2 = pq.enqueue(List.list(p(1, 1)));
-        System.out.println(pq2.toString());
+        out.println(pq2.toString());
     }
 
     @Test
@@ -27,4 +27,29 @@ public void empty() {
         assertThat(pq.isEmpty(), is(true));
     }
 
+    @Test
+    public void top() {
+        PriorityQueue<Integer, Integer> pq1 = PriorityQueue.emptyInt();
+        Option<P2<Integer, Integer>> o = pq1.top();
+        assertThat(o, is(Option.none()));
+    }
+
+    @Test
+    public void dequeue() {
+        PriorityQueue<Integer, Integer> pq1 = PriorityQueue.<Integer>emptyInt().enqueue(List.list(
+                p(3, 6), p(10, 20), p(4, 8), p(1, 2)
+        ));
+        out.println(pq1);
+        assertThat(pq1.toString(), equalTo("PriorityQueue((3: 6), (10: 20), (4: 8), (1: 2))"));
+
+        PriorityQueue<Integer, Integer> pq2 = PriorityQueue.emptyInt();
+        PriorityQueue<Integer, Integer> pq3 = pq2.dequeue();
+        out.println(pq3);
+        assertThat(pq3.toString(), equalTo("PriorityQueue()"));
+
+        PriorityQueue<Integer, Integer> pq4 = pq1.dequeue();
+        out.println(pq4);
+        assertThat(pq4.toString(), equalTo("PriorityQueue((3: 6), (4: 8), (1: 2))"));
+    }
+
 }

From 63667ffc4606be7ee33bd59b469f03ca09e4b662 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 14 Feb 2016 20:14:36 -0500
Subject: [PATCH 076/336] Add JUnit for DbState

---
 core/build.gradle                             |  2 +
 .../test/java/fj/control/db/TestDbState.java  | 55 +++++++++++++++++++
 2 files changed, 57 insertions(+)
 create mode 100644 core/src/test/java/fj/control/db/TestDbState.java

diff --git a/core/build.gradle b/core/build.gradle
index 1a1763e7..b3e1756e 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -7,6 +7,8 @@ archivesBaseName = project.projectName
 
 dependencies {
     testCompile dependencyJunit
+    testCompile 'com.h2database:h2:1.4.191'
+    testCompile 'commons-dbutils:commons-dbutils:1.6'
 }
 
 performSigning(signingEnabled, signModule)
diff --git a/core/src/test/java/fj/control/db/TestDbState.java b/core/src/test/java/fj/control/db/TestDbState.java
new file mode 100644
index 00000000..00933921
--- /dev/null
+++ b/core/src/test/java/fj/control/db/TestDbState.java
@@ -0,0 +1,55 @@
+package fj.control.db;
+
+import fj.Unit;
+import fj.data.Option;
+import org.apache.commons.dbutils.DbUtils;
+import org.junit.Test;
+
+import java.sql.*;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class TestDbState {
+    @Test
+    public void testWriter() throws SQLException {
+        final int TEN = 10;
+        DbState writer = DbState.writer(DbState.driverManager("jdbc:h2:mem:"));
+
+        DB<Unit> setup = new DB<Unit>() {
+            @Override
+            public Unit run(Connection c) throws SQLException {
+                Statement s = null;
+                try {
+                    s = c.createStatement();
+                    assertThat(s.executeUpdate("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))"), is(0));
+                    assertThat(s.executeUpdate("INSERT INTO TEST (ID, NAME) VALUES (" + TEN + ", 'FOO')"), is(1));
+                } finally {
+                    DbUtils.closeQuietly(s);
+                }
+                return Unit.unit();
+            }
+        };
+        DB<Option<Integer>> query = new DB<Option<Integer>>() {
+            @Override
+            public Option<Integer> run(Connection c) throws SQLException {
+                PreparedStatement ps = null;
+                ResultSet rs = null;
+                try {
+                    ps = c.prepareStatement("SELECT ID FROM TEST WHERE NAME = ?");
+                    ps.setString(1, "FOO");
+                    rs = ps.executeQuery();
+                    if (rs.next()) {
+                        return Option.some(rs.getInt("ID"));
+                    } else {
+                        return Option.none();
+                    }
+                } finally {
+                    DbUtils.closeQuietly(rs);
+                    DbUtils.closeQuietly(ps);
+                }
+            }
+        };
+        assertThat(writer.run(setup.bind(v -> query)).some(), is(TEN));
+    }
+}

From b943873974c06794b61ae0ea1332d87a8da30b2c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 14 Feb 2016 16:04:49 -0500
Subject: [PATCH 077/336] Add JUnit for quickcheck Bool

---
 .../src/test/java/fj/test/TestBool.java       | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 quickcheck/src/test/java/fj/test/TestBool.java

diff --git a/quickcheck/src/test/java/fj/test/TestBool.java b/quickcheck/src/test/java/fj/test/TestBool.java
new file mode 100644
index 00000000..2f29f69a
--- /dev/null
+++ b/quickcheck/src/test/java/fj/test/TestBool.java
@@ -0,0 +1,20 @@
+package fj.test;
+
+import fj.data.test.PropertyAssert;
+import org.junit.Test;
+
+import static fj.test.Arbitrary.arbBoolean;
+import static fj.test.Arbitrary.arbitrary;
+import static fj.test.Bool.bool;
+import static fj.test.Property.property;
+
+public class TestBool {
+
+    @Test
+    public void testBool() {
+        final Arbitrary<Boolean> arbBooleanR = arbitrary(arbBoolean.gen);
+        final Property p = property(arbBooleanR, arbBooleanR, (m1, m2) -> bool(m1.equals(m2))
+                .implies(m1 == m2));
+        PropertyAssert.assertResult(p);
+    }
+}

From e93d78a9d3116ab2f4f0a90a4174426ea858550a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 4 Jun 2016 14:44:03 -0400
Subject: [PATCH 078/336] Add tests for fj.Class

---
 core/src/test/java/fj/ClassTest.java | 53 ++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 core/src/test/java/fj/ClassTest.java

diff --git a/core/src/test/java/fj/ClassTest.java b/core/src/test/java/fj/ClassTest.java
new file mode 100644
index 00000000..862c6fdd
--- /dev/null
+++ b/core/src/test/java/fj/ClassTest.java
@@ -0,0 +1,53 @@
+package fj;
+
+import fj.data.List;
+import fj.data.Natural;
+import fj.data.Option;
+import fj.data.Tree;
+import org.junit.Test;
+
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.Iterator;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class ClassTest {
+    @Test
+    public void testInheritance() {
+        Class<Natural> c = Class.clas(Natural.class);
+        List<Class<? super Natural>> l = c.inheritance();
+        assertThat(l.length(), is(3));
+    }
+
+    @Test
+    public void testClassParameters() {
+        Class c = Class.clas(Option.none().getClass());
+        Tree<Type> cp = c.classParameters();
+        assertThat(cp.length(), is(1));
+    }
+
+    @Test
+    public void testSuperclassParameters() {
+        Class c = Class.clas(Option.none().getClass());
+        Tree<Type> cp = c.superclassParameters();
+        assertThat(cp.length(), is(2));
+    }
+
+    @Test
+    public void testInterfaceParameters() {
+        Class c = Class.clas(Option.none().getClass());
+        List<Type> l =c.interfaceParameters();
+        assertThat(l.length(), is(0));
+    }
+
+    @Test
+    public void testTypeParameterTree() {
+        Class c = Class.clas(Option.none().getClass());
+        Collection<Type> coll = c.classParameters().toCollection();
+        for (Type t: coll) {
+            assertThat(Class.typeParameterTree(t).toString(), is("Tree(class fj.data.Option$None)"));
+        }
+    }
+}

From 8ada2aeb55b7d8b9a3b5e1600ab164320e6b2fbf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 6 Jun 2016 19:31:57 -0400
Subject: [PATCH 079/336] Exclude demo subproject from Coveralls

---
 demo/build.gradle | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/demo/build.gradle b/demo/build.gradle
index 0b83f4f8..41841cfa 100644
--- a/demo/build.gradle
+++ b/demo/build.gradle
@@ -8,7 +8,13 @@ archivesBaseName = "${project.projectName}-${project.name}"
 configureAllRetroLambda()
 
 dependencies {
-	compile project(":core")
-	compile project(":quickcheck")
+    compile project(":core")
+    compile project(":quickcheck")
     testCompile dependencyJunit
 }
+
+test {
+    jacoco {
+        enabled = false
+    }
+}
\ No newline at end of file

From d011bf169667e6451e2796aef3a6df7190a70184 Mon Sep 17 00:00:00 2001
From: Charles O'Farrell <charleso@charleso.org>
Date: Tue, 7 Jun 2016 22:09:15 +1000
Subject: [PATCH 080/336] Remove use of Arbitrary wrapper

---
 .../java/fj/demo/test/EqualsHashCode.java     |   9 +-
 .../src/test/java/fj/data/ReaderTest.java     |   4 +-
 .../src/test/java/fj/data/TestRngState.java   |   6 +-
 .../src/test/java/fj/data/WriterTest.java     |   7 +-
 .../fj/data/properties/ArrayProperties.java   |   5 +-
 .../fj/data/properties/ListProperties.java    |  17 +-
 .../fj/data/properties/SeqProperties.java     |   9 +-
 .../fj/data/properties/SetProperties.java     |   3 +-
 .../fj/data/properties/StreamProperties.java  |   5 +-
 .../fj/data/properties/TreeMapProperties.java |   5 +-
 .../data/properties/ValidationProperties.java |   6 +-
 .../src/main/java/fj/test/Arbitrary.java      | 601 +++++++++---------
 .../src/main/java/fj/test/Coarbitrary.java    |  70 +-
 quickcheck/src/main/java/fj/test/Gen.java     |  12 +-
 .../src/main/java/fj/test/Property.java       | 290 ++++-----
 .../src/test/java/fj/data/test/TestCheck.java |   3 +-
 .../src/test/java/fj/data/test/TestNull.java  |   3 +-
 .../src/test/java/fj/test/TestBool.java       |   4 +-
 18 files changed, 513 insertions(+), 546 deletions(-)

diff --git a/demo/src/main/java/fj/demo/test/EqualsHashCode.java b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
index c5b0a898..a9f0ef2c 100644
--- a/demo/src/main/java/fj/demo/test/EqualsHashCode.java
+++ b/demo/src/main/java/fj/demo/test/EqualsHashCode.java
@@ -1,10 +1,9 @@
 package fj.demo.test;
 
 import static fj.Function.curry;
-import fj.test.Arbitrary;
+import fj.test.Gen;
 import static fj.test.Arbitrary.arbByte;
 import static fj.test.Arbitrary.arbCharacter;
-import static fj.test.Arbitrary.arbitrary;
 import static fj.test.Bool.bool;
 import static fj.test.CheckResult.summary;
 import fj.test.Property;
@@ -55,14 +54,14 @@ public int hashCode() {
 
   public static void main(final String[] args) {
     // Restrictive arbitrary for Byte, produces from three possible values.
-    final Arbitrary<Byte> arbByteR = arbitrary(arbByte.gen.map(b -> (byte)(b % 3)));
+    final Gen<Byte> arbByteR = arbByte.map(b -> (byte)(b % 3));
 
     // Restrictive arbitrary for String, produces from twelve (2 * 3 * 2) possible values.
-    final Arbitrary<String> arbStringR = arbitrary(arbCharacter.gen.bind(arbCharacter.gen, arbCharacter.gen, curry((c1, c2, c3) -> new String(new char[]{(char)(c1 % 2 + 'a'), (char)(c2 % 3 + 'a'), (char)(c3 % 2 + 'a')}))));
+    final Gen<String> arbStringR = arbCharacter.bind(arbCharacter, arbCharacter, curry((c1, c2, c3) -> new String(new char[]{(char)(c1 % 2 + 'a'), (char)(c2 % 3 + 'a'), (char)(c3 % 2 + 'a')})));
 
     // Arbitrary for MyClass that uses the restrictive arbitraries above.
     // We are using the monad pattern (bind) to make this a trivial exercise. 
-    final Arbitrary<MyClass> arbMyClass = arbitrary(arbByteR.gen.bind(arbStringR.gen, curry(MyClass::new)));
+    final Gen<MyClass> arbMyClass = arbByteR.bind(arbStringR, curry(MyClass::new));
 
     // Finally the property.
     // if m1 equals m2, then this implies that m1's hashCode is equal to m2's hashCode.
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 083716e9..05c858b8 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -52,7 +52,7 @@ public void testMapProp() {
 
     @Test
     public void testFlatMapProp() {
-        Arbitrary<F<Integer, Reader<Integer, Integer>>> a = arbF(coarbInteger, arbReader());
+        Gen<F<Integer, Reader<Integer, Integer>>> a = arbF(coarbInteger, arbReader());
         Property p = property(
                 arbF(coarbInteger, arbInteger),
                 a,
@@ -108,7 +108,7 @@ public void testAssociativity() {
         PropertyAssert.assertResult(p);
     }
 
-    public Arbitrary<Reader<Integer, Integer>> arbReader() {
+    public Gen<Reader<Integer, Integer>> arbReader() {
         return Arbitrary.arbReader(coarbInteger, arbInteger);
     }
 
diff --git a/props-core/src/test/java/fj/data/TestRngState.java b/props-core/src/test/java/fj/data/TestRngState.java
index b8a17494..ddc319b9 100644
--- a/props-core/src/test/java/fj/data/TestRngState.java
+++ b/props-core/src/test/java/fj/data/TestRngState.java
@@ -79,11 +79,11 @@ public void testTraverse() {
         Assert.assertTrue(listIntEqual.eq(list, expected));
     }
 
-    public static Arbitrary<State<LcgRng, Integer>> arbState() {
+    public static Gen<State<LcgRng, Integer>> arbState() {
         return Arbitrary.arbState(Arbitrary.arbLcgRng(), Coarbitrary.coarbLcgRng(), arbInteger);
     }
 
-    public static Arbitrary<F<LcgRng, P2<LcgRng, Integer>>> arbStateF() {
+    public static Gen<F<LcgRng, P2<LcgRng, Integer>>> arbStateF() {
         return arbF(Coarbitrary.coarbLcgRng(), arbP2(arbLcgRng(), arbInteger));
     }
 
@@ -91,7 +91,7 @@ public static Coarbitrary<State<LcgRng, Integer>> coarbState() {
         return Coarbitrary.coarbState(Arbitrary.arbLcgRng(), (LcgRng s, Integer j) -> (long) (j >= 0 ? 2 * j : -2 * j + 1));
     }
 
-    public static Arbitrary<F<Integer, State<LcgRng, Integer>>> arbBindable() {
+    public static Gen<F<Integer, State<LcgRng, Integer>>> arbBindable() {
         return arbF(coarbInteger, arbState());
     }
 
diff --git a/props-core/src/test/java/fj/data/WriterTest.java b/props-core/src/test/java/fj/data/WriterTest.java
index 158a2314..a2af9952 100644
--- a/props-core/src/test/java/fj/data/WriterTest.java
+++ b/props-core/src/test/java/fj/data/WriterTest.java
@@ -4,6 +4,7 @@
 import fj.F;
 import fj.data.test.PropertyAssert;
 import fj.test.Arbitrary;
+import fj.test.Gen;
 import fj.test.Property;
 import org.junit.Assert;
 import org.junit.Test;
@@ -62,12 +63,12 @@ public void testFlatMap() {
 
     }
 
-    public Arbitrary<Writer<String, Integer>> arbWriterStringInt() {
+    public Gen<Writer<String, Integer>> arbWriterStringInt() {
         return arbWriterString(arbInteger);
     }
 
-    public <A> Arbitrary<Writer<String, A>> arbWriterString(Arbitrary<A> arb) {
-        return Arbitrary.arbitrary(arb.gen.map(a -> Writer.<A>stringLogger().f(a)));
+    public <A> Gen<Writer<String, A>> arbWriterString(Gen<A> arb) {
+        return arb.map(a -> Writer.<A>stringLogger().f(a));
     }
 
     // Left identity: return a >>= f == f a
diff --git a/props-core/src/test/java/fj/data/properties/ArrayProperties.java b/props-core/src/test/java/fj/data/properties/ArrayProperties.java
index c6aea391..feb5dcf4 100644
--- a/props-core/src/test/java/fj/data/properties/ArrayProperties.java
+++ b/props-core/src/test/java/fj/data/properties/ArrayProperties.java
@@ -3,7 +3,6 @@
 import fj.*;
 import fj.data.Array;
 import fj.data.Either;
-import fj.test.Arbitrary;
 import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -31,9 +30,9 @@ public class ArrayProperties {
 
   private static final Equal<Array<Integer>> eq = arrayEqual(intEqual);
 
-  private static final Arbitrary<P2<Array<Integer>, Integer>> arbArrayWithIndex = arbitrary(arbArray(arbInteger).gen
+  private static final Gen<P2<Array<Integer>, Integer>> arbArrayWithIndex = arbArray(arbInteger)
     .filter(Array::isNotEmpty)
-    .bind(array -> Gen.choose(0, array.length() - 1).map(i -> P.p(array, i))));
+    .bind(array -> Gen.choose(0, array.length() - 1).map(i -> P.p(array, i)));
 
   public Property isEmpty() {
     return property(arbArray(arbInteger), array -> prop(array.isEmpty() != array.isNotEmpty()));
diff --git a/props-core/src/test/java/fj/data/properties/ListProperties.java b/props-core/src/test/java/fj/data/properties/ListProperties.java
index 825a5f17..9724488f 100644
--- a/props-core/src/test/java/fj/data/properties/ListProperties.java
+++ b/props-core/src/test/java/fj/data/properties/ListProperties.java
@@ -4,7 +4,6 @@
 import fj.data.List;
 import fj.data.Stream;
 import fj.data.TreeMap;
-import fj.test.Arbitrary;
 import fj.test.reflect.CheckParams;
 import fj.test.runner.PropertyTestRunner;
 import fj.test.Gen;
@@ -36,9 +35,9 @@ public class ListProperties {
 
   private static final Equal<List<Integer>> eq = listEqual(intEqual);
 
-  private static final Arbitrary<P2<List<Integer>, Integer>> arbListWithIndex = arbitrary(arbList(arbInteger).gen
+  private static final Gen<P2<List<Integer>, Integer>> arbListWithIndex = arbList(arbInteger)
     .filter(List::isNotEmpty)
-    .bind(list -> Gen.choose(0, list.length() - 1).map(i -> p(list, i))));
+    .bind(list -> Gen.choose(0, list.length() - 1).map(i -> p(list, i)));
 
   public Property isEmpty() {
     return property(arbList(arbInteger), list -> prop(list.isEmpty() != list.isNotEmpty()));
@@ -172,11 +171,11 @@ public Property appendLength() {
 
   @CheckParams(minSize = 2, maxSize = 10000)
   public Property indexTail() {
-    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger).gen
+    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger)
       .filter(list -> list.length() > 1)
       .bind(list -> Gen.choose(1, list.length() - 1).map(i -> p(list, i)));
 
-    return property(Arbitrary.arbitrary(gen), pair -> {
+    return property(gen, pair -> {
       final List<Integer> list = pair._1();
       final int i = pair._2();
       return prop(intEqual.eq(list.index(i), list.tail().index(i - 1)));
@@ -277,17 +276,17 @@ public Property groupByMonoid() {
   }
 
   public Property isPrefixOf() {
-    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger).gen.bind(list ->
+    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger).bind(list ->
       Gen.choose(0, list.length()).map(i -> p(list, i)));
 
-    return property(arbitrary(gen), pair -> prop(pair._1().take(pair._2()).isPrefixOf(intEqual, pair._1())));
+    return property(gen, pair -> prop(pair._1().take(pair._2()).isPrefixOf(intEqual, pair._1())));
   }
 
   public Property isSuffixOf() {
-    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger).gen.bind(list ->
+    final Gen<P2<List<Integer>, Integer>> gen = arbList(arbInteger).bind(list ->
       Gen.choose(0, list.length()).map(i -> p(list, i)));
 
-    return property(arbitrary(gen), pair -> prop(pair._1().drop(pair._2()).isSuffixOf(intEqual, pair._1())));
+    return property(gen, pair -> prop(pair._1().drop(pair._2()).isSuffixOf(intEqual, pair._1())));
   }
 
   public Property isPrefixOfShorter() {
diff --git a/props-core/src/test/java/fj/data/properties/SeqProperties.java b/props-core/src/test/java/fj/data/properties/SeqProperties.java
index 8e8076aa..eedbcc5c 100644
--- a/props-core/src/test/java/fj/data/properties/SeqProperties.java
+++ b/props-core/src/test/java/fj/data/properties/SeqProperties.java
@@ -6,7 +6,6 @@
 import fj.data.Seq;
 import fj.test.reflect.CheckParams;
 import fj.test.runner.PropertyTestRunner;
-import fj.test.Arbitrary;
 import fj.test.Gen;
 import fj.test.Property;
 import org.junit.runner.RunWith;
@@ -21,9 +20,9 @@
 @CheckParams(maxSize = 10000)
 public class SeqProperties {
 
-  private static final Arbitrary<P2<Seq<Integer>, Integer>> arbSeqWithIndex = arbitrary(arbSeq(arbInteger).gen
+  private static final Gen<P2<Seq<Integer>, Integer>> arbSeqWithIndex = arbSeq(arbInteger)
     .filter(Seq::isNotEmpty)
-    .bind(seq -> Gen.choose(0, seq.length() - 1).map(i -> P.p(seq, i))));
+    .bind(seq -> Gen.choose(0, seq.length() - 1).map(i -> P.p(seq, i)));
 
   public Property consHead() {
     return property(arbSeq(arbInteger), arbInteger, (seq, n) -> prop(seq.cons(n).head().equals(n)));
@@ -107,12 +106,12 @@ public Property delete() {
   }
 
   public Property foldLeft() {
-    return property(arbSeq(arbitrary(Gen.value(1))), seq ->
+    return property(arbSeq(Gen.value(1)), seq ->
       prop(seq.foldLeft((acc, i) -> acc + i, 0) == seq.length()));
   }
 
   public Property foldRight() {
-    return property(arbSeq(arbitrary(Gen.value(1))), seq ->
+    return property(arbSeq(Gen.value(1)), seq ->
       prop(seq.foldRight((i, acc) -> acc + i, 0) == seq.length()));
   }
 
diff --git a/props-core/src/test/java/fj/data/properties/SetProperties.java b/props-core/src/test/java/fj/data/properties/SetProperties.java
index 84c7e40c..5349b650 100644
--- a/props-core/src/test/java/fj/data/properties/SetProperties.java
+++ b/props-core/src/test/java/fj/data/properties/SetProperties.java
@@ -6,6 +6,7 @@
 import fj.data.Set;
 import fj.data.Stream;
 import fj.test.Arbitrary;
+import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
 import fj.test.runner.PropertyTestRunner;
@@ -22,7 +23,7 @@
 public class SetProperties {
 
     public final static int maxSize = 20;
-    public final static Arbitrary<Set<Integer>> as = Arbitrary.arbSet(Ord.intOrd, Arbitrary.arbInteger, maxSize);
+    public final static Gen<Set<Integer>> as = Arbitrary.arbSet(Ord.intOrd, Arbitrary.arbInteger, maxSize);
     public final static Equal<List<Integer>> eq = Equal.listEqual(Equal.intEqual);
 
 	Property setToListIsSorted() {
diff --git a/props-core/src/test/java/fj/data/properties/StreamProperties.java b/props-core/src/test/java/fj/data/properties/StreamProperties.java
index f68df0bc..07bc7897 100644
--- a/props-core/src/test/java/fj/data/properties/StreamProperties.java
+++ b/props-core/src/test/java/fj/data/properties/StreamProperties.java
@@ -3,7 +3,6 @@
 import fj.*;
 import fj.data.Either;
 import fj.data.Stream;
-import fj.test.Arbitrary;
 import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -170,11 +169,11 @@ public Property reverse() {
 
   @CheckParams(minSize = 2, maxSize = 10000)
   public Property indexTail() {
-    final Gen<P2<Stream<Integer>, Integer>> gen = arbStream(arbInteger).gen
+    final Gen<P2<Stream<Integer>, Integer>> gen = arbStream(arbInteger)
       .filter(stream -> stream.length() > 1)
       .bind(stream -> Gen.choose(1, stream.length() - 1).map(i -> P.p(stream, i)));
 
-    return property(Arbitrary.arbitrary(gen), pair -> {
+    return property(gen, pair -> {
       final Stream<Integer> stream = pair._1();
       final int i = pair._2();
       return prop(intEqual.eq(stream.index(i), stream.tail()._1().index(i - 1)));
diff --git a/props-core/src/test/java/fj/data/properties/TreeMapProperties.java b/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
index 8dd718ee..eb71749b 100644
--- a/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
+++ b/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
@@ -6,7 +6,6 @@
 import fj.data.List;
 import fj.data.Stream;
 import fj.data.TreeMap;
-import fj.test.Arbitrary;
 import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -33,8 +32,8 @@ public class TreeMapProperties {
 
     private static final int smallMax = 5;
     private static final int midMax = 20;
-    public static final Arbitrary<TreeMap<Integer, String>> smallArbTreeMapIS = arbTreeMap(intOrd, arbInteger, arbString, smallMax);
-    public static final Arbitrary<TreeMap<Integer, String>> arbTreeMapIS = arbTreeMap(intOrd, arbInteger, arbString, midMax);
+    public static final Gen<TreeMap<Integer, String>> smallArbTreeMapIS = arbTreeMap(intOrd, arbInteger, arbString, smallMax);
+    public static final Gen<TreeMap<Integer, String>> arbTreeMapIS = arbTreeMap(intOrd, arbInteger, arbString, midMax);
     public static final Ord<P2<Integer, String>> p2Ord = Ord.p2Ord1(Ord.intOrd);
     Equal<List<P2<Integer, String>>> listEq = Equal.listEqual(p2Equal(intEqual, stringEqual));
 
diff --git a/props-core/src/test/java/fj/data/properties/ValidationProperties.java b/props-core/src/test/java/fj/data/properties/ValidationProperties.java
index d9580cc4..f5205d73 100644
--- a/props-core/src/test/java/fj/data/properties/ValidationProperties.java
+++ b/props-core/src/test/java/fj/data/properties/ValidationProperties.java
@@ -4,7 +4,7 @@
 import fj.Semigroup;
 import fj.data.List;
 import fj.data.Validation;
-import fj.test.Arbitrary;
+import fj.test.Gen;
 import fj.test.Property;
 import fj.test.runner.PropertyTestRunner;
 import org.junit.runner.RunWith;
@@ -20,7 +20,7 @@
 public class ValidationProperties {
 
     public Property partition() {
-        Arbitrary<List<Validation<String, Integer>>> al = arbList(arbValidation(arbUSASCIIString, arbInteger));
+        Gen<List<Validation<String, Integer>>> al = arbList(arbValidation(arbUSASCIIString, arbInteger));
         return Property.property(al, list -> {
             P2<List<String>, List<Integer>> p = Validation.partition(list);
             boolean b1 = p._1().length() + p._2().length() == list.length();
@@ -31,7 +31,7 @@ public Property partition() {
     }
 
     public Property sequenceNonCumulative() {
-        Arbitrary<List<Validation<String, Integer>>> al = arbList(arbValidation(arbUSASCIIString, arbInteger));
+        Gen<List<Validation<String, Integer>>> al = arbList(arbValidation(arbUSASCIIString, arbInteger));
         return Property.property(al, list -> {
             Validation<List<String>, List<Integer>> v = Validation.sequenceNonCumulative(list);
             Property p1 = implies(
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index e2a00b29..0b82108f 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -74,31 +74,11 @@
 import java.util.concurrent.SynchronousQueue;
 
 /**
- * The type used to generate arbitrary values of the given type parameter (<code>A</code>). Common
- * arbitrary implementations are provided.
+ * Common Gen helper functions.
  *
  * @version %build.number%
  */
-public final class Arbitrary<A> {
-  /**
-   * The generator associated with this arbitrary.
-   */
-  @SuppressWarnings("PublicField")
-  public final Gen<A> gen;
-
-  private Arbitrary(final Gen<A> gen) {
-    this.gen = gen;
-  }
-
-  /**
-   * Constructs and arbitrary with the given generator.
-   *
-   * @param g The generator to construct an arbitrary with.
-   * @return A new arbitrary that uses the given generator.
-   */
-  public static <A> Arbitrary<A> arbitrary(final Gen<A> g) {
-    return new Arbitrary<>(g);
-  }
+public final class Arbitrary {
 
   /**
    * An arbitrary for functions.
@@ -107,30 +87,30 @@ public static <A> Arbitrary<A> arbitrary(final Gen<A> g) {
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for functions.
    */
-  public static <A, B> Arbitrary<F<A, B>> arbF(final Coarbitrary<A> c, final Arbitrary<B> a) {
-    return arbitrary(promote(new F<A, Gen<B>>() {
+  public static <A, B> Gen<F<A, B>> arbF(final Coarbitrary<A> c, final Gen<B> a) {
+    return promote(new F<A, Gen<B>>() {
       public Gen<B> f(final A x) {
-        return c.coarbitrary(x, a.gen);
+        return c.coarbitrary(x, a);
       }
-    }));
+    });
   }
 
-    public static <A, B> Arbitrary<Reader<A, B>> arbReader(Coarbitrary<A> aa, Arbitrary<B> ab) {
-        return arbitrary(arbF(aa, ab).gen.map(Reader::unit));
+    public static <A, B> Gen<Reader<A, B>> arbReader(Coarbitrary<A> aa, Gen<B> ab) {
+        return arbF(aa, ab).map(Reader::unit);
     }
 
     /**
      * An arbitrary for state.
      */
-    public static <S, A> Arbitrary<State<S, A>> arbState(Arbitrary<S> as, Coarbitrary<S> cs, Arbitrary<A> aa) {
-        return arbitrary(arbF(cs, arbP2(as, aa)).gen.map(State::unit));
+    public static <S, A> Gen<State<S, A>> arbState(Gen<S> as, Coarbitrary<S> cs, Gen<A> aa) {
+        return arbF(cs, arbP2(as, aa)).map(State::unit);
     }
 
     /**
      * An arbitrary for the LcgRng.
      */
-    public static <A> Arbitrary<LcgRng> arbLcgRng() {
-        return arbitrary(Arbitrary.arbLong.gen.map(LcgRng::new));
+    public static <A> Gen<LcgRng> arbLcgRng() {
+        return Arbitrary.arbLong.map(LcgRng::new);
     }
 
   /**
@@ -139,8 +119,8 @@ public static <A> Arbitrary<LcgRng> arbLcgRng() {
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for functions.
    */
-  public static <A, B> Arbitrary<F<A, B>> arbFInvariant(final Arbitrary<B> a) {
-    return arbitrary(a.gen.map(Function.constant()));
+  public static <A, B> Gen<F<A, B>> arbFInvariant(final Gen<B> a) {
+    return a.map(Function.constant());
   }
 
   /**
@@ -151,9 +131,9 @@ public static <A, B> Arbitrary<F<A, B>> arbFInvariant(final Arbitrary<B> a) {
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-2.
    */
-  public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                       final Arbitrary<C> a) {
-    return arbitrary(arbF(ca, arbF(cb, a)).gen.map(Function.uncurryF2()));
+  public static <A, B, C> Gen<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
+                                                 final Gen<C> a) {
+    return arbF(ca, arbF(cb, a)).map(Function.uncurryF2());
   }
 
   /**
@@ -162,9 +142,8 @@ public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, fi
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-2.
    */
-  public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2Invariant(final Arbitrary<C> a) {
-    return arbitrary(a.gen.map(
-        compose(Function.uncurryF2(), compose(Function.constant(), Function.constant()))));
+  public static <A, B, C> Gen<F2<A, B, C>> arbF2Invariant(final Gen<C> a) {
+    return a.map(compose(Function.uncurryF2(), compose(Function.constant(), Function.constant())));
   }
 
   /**
@@ -176,9 +155,9 @@ public static <A, B, C> Arbitrary<F2<A, B, C>> arbF2Invariant(final Arbitrary<C>
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-3.
    */
-  public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                             final Coarbitrary<C> cc, final Arbitrary<D> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, a))).gen.map(Function.uncurryF3()));
+  public static <A, B, C, D> Gen<F3<A, B, C, D>> arbF3(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
+                                                       final Coarbitrary<C> cc, final Gen<D> a) {
+    return arbF(ca, arbF(cb, arbF(cc, a))).map(Function.uncurryF3());
   }
 
   /**
@@ -187,11 +166,11 @@ public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3(final Coarbitrary<A>
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-3.
    */
-  public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3Invariant(final Arbitrary<D> a) {
-    return arbitrary(a.gen.map(compose(Function.uncurryF3(), compose(Function.constant(),
+  public static <A, B, C, D> Gen<F3<A, B, C, D>> arbF3Invariant(final Gen<D> a) {
+    return a.map(compose(Function.uncurryF3(), compose(Function.constant(),
                                                                                  compose(
                                                                                      Function.constant(),
-                                                                                     Function.constant())))));
+                                                                                     Function.constant()))));
   }
 
   /**
@@ -204,10 +183,10 @@ public static <A, B, C, D> Arbitrary<F3<A, B, C, D>> arbF3Invariant(final Arbitr
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-4.
    */
-  public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                                   final Coarbitrary<C> cc, final Coarbitrary<D> cd,
-                                                                   final Arbitrary<E> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, a)))).gen.map(Function.uncurryF4()));
+  public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
+                                                             final Coarbitrary<C> cc, final Coarbitrary<D> cd,
+                                                             final Gen<E> a) {
+    return arbF(ca, arbF(cb, arbF(cc, arbF(cd, a)))).map(Function.uncurryF4());
   }
 
   /**
@@ -216,12 +195,12 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4(final Coarbitra
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-4.
    */
-  public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final Arbitrary<E> a) {
-    return arbitrary(a.gen.map(compose(Function.uncurryF4(),
+  public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E> a) {
+    return a.map(compose(Function.uncurryF4(),
                                        compose(Function.constant(),
                                                compose(Function.constant(),
                                                        compose(Function.constant(),
-                                                               Function.constant()))))));
+                                                               Function.constant())))));
   }
 
   /**
@@ -235,14 +214,13 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-5.
    */
-  public static <A, B, C, D, E, F$> Arbitrary<F5<A, B, C, D, E, F$>> arbF5(final Coarbitrary<A> ca,
-                                                                           final Coarbitrary<B> cb,
-                                                                           final Coarbitrary<C> cc,
-                                                                           final Coarbitrary<D> cd,
-                                                                           final Coarbitrary<E> ce,
-                                                                           final Arbitrary<F$> a) {
-    return arbitrary(
-        arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, a))))).gen.map(Function.uncurryF5()));
+  public static <A, B, C, D, E, F$> Gen<F5<A, B, C, D, E, F$>> arbF5(final Coarbitrary<A> ca,
+                                                                     final Coarbitrary<B> cb,
+                                                                     final Coarbitrary<C> cc,
+                                                                     final Coarbitrary<D> cd,
+                                                                     final Coarbitrary<E> ce,
+                                                                     final Gen<F$> a) {
+    return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, a))))).map(Function.uncurryF5());
   }
 
   /**
@@ -251,13 +229,13 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-5.
    */
-  public static <A, B, C, D, E, F$> Arbitrary<F5<A, B, C, D, E, F$>> arbF5Invariant(final Arbitrary<F$> a) {
-    return arbitrary(a.gen.map(compose(Function.uncurryF5(),
+  public static <A, B, C, D, E, F$> Gen<F5<A, B, C, D, E, F$>> arbF5Invariant(final Gen<F$> a) {
+    return a.map(compose(Function.uncurryF5(),
                                        compose(Function.constant(),
                                                compose(Function.constant(),
                                                        compose(Function.constant(),
                                                                compose(Function.constant(),
-                                                                       Function.constant())))))));
+                                                                       Function.constant()))))));
   }
 
   /**
@@ -272,15 +250,15 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-6.
    */
-  public static <A, B, C, D, E, F$, G> Arbitrary<F6<A, B, C, D, E, F$, G>> arbF6(final Coarbitrary<A> ca,
-                                                                                 final Coarbitrary<B> cb,
-                                                                                 final Coarbitrary<C> cc,
-                                                                                 final Coarbitrary<D> cd,
-                                                                                 final Coarbitrary<E> ce,
-                                                                                 final Coarbitrary<F$> cf,
-                                                                                 final Arbitrary<G> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, a)))))).gen.map(
-        Function.uncurryF6()));
+  public static <A, B, C, D, E, F$, G> Gen<F6<A, B, C, D, E, F$, G>> arbF6(final Coarbitrary<A> ca,
+                                                                           final Coarbitrary<B> cb,
+                                                                           final Coarbitrary<C> cc,
+                                                                           final Coarbitrary<D> cd,
+                                                                           final Coarbitrary<E> ce,
+                                                                           final Coarbitrary<F$> cf,
+                                                                           final Gen<G> a) {
+    return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, a)))))).map(
+        Function.uncurryF6());
   }
 
   /**
@@ -289,14 +267,14 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-6.
    */
-  public static <A, B, C, D, E, F$, G> Arbitrary<F6<A, B, C, D, E, F$, G>> arbF6Invariant(final Arbitrary<G> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G>uncurryF6(),
+  public static <A, B, C, D, E, F$, G> Gen<F6<A, B, C, D, E, F$, G>> arbF6Invariant(final Gen<G> a) {
+    return a.map(compose(Function.<A, B, C, D, E, F$, G>uncurryF6(),
         compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>>constant(),
             compose(Function.<B, F<C, F<D, F<E, F<F$, G>>>>>constant(),
                 compose(Function.<C, F<D, F<E, F<F$, G>>>>constant(),
                     compose(Function.<D, F<E, F<F$, G>>>constant(),
                         compose(Function.<E, F<F$, G>>constant(),
-                            Function.<F$, G>constant()))))))));
+                            Function.<F$, G>constant())))))));
   }
 
   /**
@@ -312,16 +290,16 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-7.
    */
-  public static <A, B, C, D, E, F$, G, H> Arbitrary<F7<A, B, C, D, E, F$, G, H>> arbF7(final Coarbitrary<A> ca,
-                                                                                       final Coarbitrary<B> cb,
-                                                                                       final Coarbitrary<C> cc,
-                                                                                       final Coarbitrary<D> cd,
-                                                                                       final Coarbitrary<E> ce,
-                                                                                       final Coarbitrary<F$> cf,
-                                                                                       final Coarbitrary<G> cg,
-                                                                                       final Arbitrary<H> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, a))))))).gen.map(
-        Function.uncurryF7()));
+  public static <A, B, C, D, E, F$, G, H> Gen<F7<A, B, C, D, E, F$, G, H>> arbF7(final Coarbitrary<A> ca,
+                                                                                 final Coarbitrary<B> cb,
+                                                                                 final Coarbitrary<C> cc,
+                                                                                 final Coarbitrary<D> cd,
+                                                                                 final Coarbitrary<E> ce,
+                                                                                 final Coarbitrary<F$> cf,
+                                                                                 final Coarbitrary<G> cg,
+                                                                                 final Gen<H> a) {
+    return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, a))))))).map(
+        Function.uncurryF7());
   }
 
   /**
@@ -330,15 +308,15 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-7.
    */
-  public static <A, B, C, D, E, F$, G, H> Arbitrary<F7<A, B, C, D, E, F$, G, H>> arbF7Invariant(final Arbitrary<H> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G, H>uncurryF7(),
+  public static <A, B, C, D, E, F$, G, H> Gen<F7<A, B, C, D, E, F$, G, H>> arbF7Invariant(final Gen<H> a) {
+    return a.map(compose(Function.<A, B, C, D, E, F$, G, H>uncurryF7(),
         compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>>constant(),
             compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>constant(),
                 compose(Function.<C, F<D, F<E, F<F$, F<G, H>>>>>constant(),
                     compose(Function.<D, F<E, F<F$, F<G, H>>>>constant(),
                         compose(Function.<E, F<F$, F<G, H>>>constant(),
                             compose(Function.<F$, F<G, H>>constant(),
-                                Function.<G, H>constant())))))))));
+                                Function.<G, H>constant()))))))));
   }
 
   /**
@@ -355,17 +333,17 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-8.
    */
-  public static <A, B, C, D, E, F$, G, H, I> Arbitrary<F8<A, B, C, D, E, F$, G, H, I>> arbF8(final Coarbitrary<A> ca,
-                                                                                             final Coarbitrary<B> cb,
-                                                                                             final Coarbitrary<C> cc,
-                                                                                             final Coarbitrary<D> cd,
-                                                                                             final Coarbitrary<E> ce,
-                                                                                             final Coarbitrary<F$> cf,
-                                                                                             final Coarbitrary<G> cg,
-                                                                                             final Coarbitrary<H> ch,
-                                                                                             final Arbitrary<I> a) {
-    return arbitrary(arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, arbF(ch, a)))))))).gen.map(
-        Function.uncurryF8()));
+  public static <A, B, C, D, E, F$, G, H, I> Gen<F8<A, B, C, D, E, F$, G, H, I>> arbF8(final Coarbitrary<A> ca,
+                                                                                       final Coarbitrary<B> cb,
+                                                                                       final Coarbitrary<C> cc,
+                                                                                       final Coarbitrary<D> cd,
+                                                                                       final Coarbitrary<E> ce,
+                                                                                       final Coarbitrary<F$> cf,
+                                                                                       final Coarbitrary<G> cg,
+                                                                                       final Coarbitrary<H> ch,
+                                                                                       final Gen<I> a) {
+    return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, arbF(ch, a)))))))).map(
+        Function.uncurryF8());
   }
 
   /**
@@ -374,9 +352,9 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for function-8.
    */
-  public static <A, B, C, D, E, F$, G, H, I> Arbitrary<F8<A, B, C, D, E, F$, G, H, I>> arbF8Invariant(
-      final Arbitrary<I> a) {
-    return arbitrary(a.gen.map(compose(Function.<A, B, C, D, E, F$, G, H, I>uncurryF8(),
+  public static <A, B, C, D, E, F$, G, H, I> Gen<F8<A, B, C, D, E, F$, G, H, I>> arbF8Invariant(
+      final Gen<I> a) {
+    return a.map(compose(Function.<A, B, C, D, E, F$, G, H, I>uncurryF8(),
         compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>>constant(),
             compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>constant(),
                 compose(Function.<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>constant(),
@@ -386,25 +364,25 @@ public static <A, B, C, D, E> Arbitrary<F4<A, B, C, D, E>> arbF4Invariant(final
                             compose(
                                 Function.<F$, F<G, F<H, I>>>constant(),
                                 compose(Function.<G, F<H, I>>constant(),
-                                    Function.<H, I>constant()))))))))));
+                                    Function.<H, I>constant())))))))));
   }
 
   /**
    * An arbitrary implementation for boolean values.
    */
-  public static final Arbitrary<Boolean> arbBoolean = arbitrary(elements(true, false));
+  public static final Gen<Boolean> arbBoolean = elements(true, false);
 
   /**
    * An arbitrary implementation for integer values.
    */
-  public static final Arbitrary<Integer> arbInteger = arbitrary(sized(i -> choose(-i, i)));
+  public static final Gen<Integer> arbInteger = sized(i -> choose(-i, i));
 
   /**
    * An arbitrary implementation for integer values that checks boundary values <code>(0, 1, -1,
    * max, min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link
    * #arbInteger} the remainder of the time (93%).
    */
-  public static final Arbitrary<Integer> arbIntegerBoundaries = arbitrary(sized(new F<Integer, Gen<Integer>>() {
+  public static final Gen<Integer> arbIntegerBoundaries = sized(new F<Integer, Gen<Integer>>() {
     @SuppressWarnings("unchecked")
     public Gen<Integer> f(final Integer i) {
       return frequency(list(p(1, value(0)),
@@ -414,22 +392,22 @@ public Gen<Integer> f(final Integer i) {
                             p(1, value(Integer.MIN_VALUE)),
                             p(1, value(Integer.MAX_VALUE - 1)),
                             p(1, value(Integer.MIN_VALUE + 1)),
-                            p(93, arbInteger.gen)));
+                            p(93, arbInteger)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for long values.
    */
-  public static final Arbitrary<Long> arbLong =
-      arbitrary(arbInteger.gen.bind(arbInteger.gen, i1 -> i2 -> (long) i1 << 32L & i2));
+  public static final Gen<Long> arbLong =
+      arbInteger.bind(arbInteger, i1 -> i2 -> (long) i1 << 32L & i2);
 
   /**
    * An arbitrary implementation for long values that checks boundary values <code>(0, 1, -1, max,
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbLong}
    * the remainder of the time (93%).
    */
-  public static final Arbitrary<Long> arbLongBoundaries = arbitrary(sized(new F<Integer, Gen<Long>>() {
+  public static final Gen<Long> arbLongBoundaries = sized(new F<Integer, Gen<Long>>() {
     @SuppressWarnings("unchecked")
     public Gen<Long> f(final Integer i) {
       return frequency(list(p(1, value(0L)),
@@ -439,21 +417,21 @@ public Gen<Long> f(final Integer i) {
                             p(1, value(Long.MIN_VALUE)),
                             p(1, value(Long.MAX_VALUE - 1L)),
                             p(1, value(Long.MIN_VALUE + 1L)),
-                            p(93, arbLong.gen)));
+                            p(93, arbLong)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for byte values.
    */
-  public static final Arbitrary<Byte> arbByte = arbitrary(arbInteger.gen.map(i -> (byte) i.intValue()));
+  public static final Gen<Byte> arbByte = arbInteger.map(i -> (byte) i.intValue());
 
   /**
    * An arbitrary implementation for byte values that checks boundary values <code>(0, 1, -1, max,
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbByte}
    * the remainder of the time (93%).
    */
-  public static final Arbitrary<Byte> arbByteBoundaries = arbitrary(sized(new F<Integer, Gen<Byte>>() {
+  public static final Gen<Byte> arbByteBoundaries = sized(new F<Integer, Gen<Byte>>() {
     @SuppressWarnings("unchecked")
     public Gen<Byte> f(final Integer i) {
       return frequency(list(p(1, value((byte) 0)),
@@ -463,21 +441,21 @@ public Gen<Byte> f(final Integer i) {
                             p(1, value(Byte.MIN_VALUE)),
                             p(1, value((byte) (Byte.MAX_VALUE - 1))),
                             p(1, value((byte) (Byte.MIN_VALUE + 1))),
-                            p(93, arbByte.gen)));
+                            p(93, arbByte)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for short values.
    */
-  public static final Arbitrary<Short> arbShort = arbitrary(arbInteger.gen.map(i -> (short) i.intValue()));
+  public static final Gen<Short> arbShort = arbInteger.map(i -> (short) i.intValue());
 
   /**
    * An arbitrary implementation for short values that checks boundary values <code>(0, 1, -1, max,
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbShort}
    * the remainder of the time (93%).
    */
-  public static final Arbitrary<Short> arbShortBoundaries = arbitrary(sized(new F<Integer, Gen<Short>>() {
+  public static final Gen<Short> arbShortBoundaries = sized(new F<Integer, Gen<Short>>() {
     @SuppressWarnings("unchecked")
     public Gen<Short> f(final Integer i) {
       return frequency(list(p(1, value((short) 0)),
@@ -487,42 +465,42 @@ public Gen<Short> f(final Integer i) {
                             p(1, value(Short.MIN_VALUE)),
                             p(1, value((short) (Short.MAX_VALUE - 1))),
                             p(1, value((short) (Short.MIN_VALUE + 1))),
-                            p(93, arbShort.gen)));
+                            p(93, arbShort)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for character values.
    */
-  public static final Arbitrary<Character> arbCharacter = arbitrary(choose(0, 65536).map(i -> (char) i.intValue()));
+  public static final Gen<Character> arbCharacter = choose(0, 65536).map(i -> (char) i.intValue());
 
   /**
    * An arbitrary implementation for character values that checks boundary values <code>(max, min,
    * max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbCharacter}
    * the remainder of the time (96%).
    */
-  public static final Arbitrary<Character> arbCharacterBoundaries = arbitrary(sized(new F<Integer, Gen<Character>>() {
+  public static final Gen<Character> arbCharacterBoundaries = sized(new F<Integer, Gen<Character>>() {
     @SuppressWarnings("unchecked")
     public Gen<Character> f(final Integer i) {
       return frequency(list(p(1, value(Character.MIN_VALUE)),
                             p(1, value((char) (Character.MIN_VALUE + 1))),
                             p(1, value(Character.MAX_VALUE)),
                             p(1, value((char) (Character.MAX_VALUE - 1))),
-                            p(95, arbCharacter.gen)));
+                            p(95, arbCharacter)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for double values.
    */
-  public static final Arbitrary<Double> arbDouble = arbitrary(sized(i -> choose((double) -i, i)));
+  public static final Gen<Double> arbDouble = sized(i -> choose((double) -i, i));
 
   /**
    * An arbitrary implementation for double values that checks boundary values <code>(0, 1, -1, max,
    * min, min (normal), NaN, -infinity, infinity, max - 1)</code> with a frequency of 1% each then
    * generates from {@link #arbDouble} the remainder of the time (91%).
    */
-  public static final Arbitrary<Double> arbDoubleBoundaries = arbitrary(sized(new F<Integer, Gen<Double>>() {
+  public static final Gen<Double> arbDoubleBoundaries = sized(new F<Integer, Gen<Double>>() {
     @SuppressWarnings("unchecked")
     public Gen<Double> f(final Integer i) {
       return frequency(list(p(1, value(0D)),
@@ -534,21 +512,21 @@ public Gen<Double> f(final Integer i) {
                             p(1, value(Double.NEGATIVE_INFINITY)),
                             p(1, value(Double.POSITIVE_INFINITY)),
                             p(1, value(Double.MAX_VALUE - 1D)),
-                            p(91, arbDouble.gen)));
+                            p(91, arbDouble)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for float values.
    */
-  public static final Arbitrary<Float> arbFloat = arbitrary(arbDouble.gen.map(d -> (float) d.doubleValue()));
+  public static final Gen<Float> arbFloat = arbDouble.map(d -> (float) d.doubleValue());
 
   /**
    * An arbitrary implementation for float values that checks boundary values <code>(0, 1, -1, max,
    * min, NaN, -infinity, infinity, max - 1)</code> with a frequency of 1% each then generates from
    * {@link #arbFloat} the remainder of the time (91%).
    */
-  public static final Arbitrary<Float> arbFloatBoundaries = arbitrary(sized(new F<Integer, Gen<Float>>() {
+  public static final Gen<Float> arbFloatBoundaries = sized(new F<Integer, Gen<Float>>() {
     @SuppressWarnings("unchecked")
     public Gen<Float> f(final Integer i) {
       return frequency(list(p(1, value(0F)),
@@ -560,41 +538,41 @@ public Gen<Float> f(final Integer i) {
                             p(1, value(Float.NEGATIVE_INFINITY)),
                             p(1, value(Float.POSITIVE_INFINITY)),
                             p(1, value(Float.MAX_VALUE - 1F)),
-                            p(91, arbFloat.gen)));
+                            p(91, arbFloat)));
     }
-  }));
+  });
 
   /**
    * An arbitrary implementation for string values.
    */
-  public static final Arbitrary<String> arbString =
-      arbitrary(arbList(arbCharacter).gen.map(List::asString));
+  public static final Gen<String> arbString =
+      arbList(arbCharacter).map(List::asString);
 
   /**
    * An arbitrary implementation for string values with characters in the US-ASCII range.
    */
-  public static final Arbitrary<String> arbUSASCIIString =
-      arbitrary(arbList(arbCharacter).gen.map(cs -> asString(cs.map(c -> (char) (c % 128)))));
+  public static final Gen<String> arbUSASCIIString =
+      arbList(arbCharacter).map(cs -> asString(cs.map(c -> (char) (c % 128))));
 
   /**
    * An arbitrary implementation for string values with alpha-numeric characters.
    */
-  public static final Arbitrary<String> arbAlphaNumString =
-      arbitrary(arbList(arbitrary(elements(range(charEnumerator, 'a', 'z').append(
+  public static final Gen<String> arbAlphaNumString =
+      arbList(elements(range(charEnumerator, 'a', 'z').append(
           range(charEnumerator, 'A', 'Z')).append(
-          range(charEnumerator, '0', '9')).toArray().array(Character[].class)))).gen.map(asString()));
+          range(charEnumerator, '0', '9')).toArray().array(Character[].class))).map(asString());
 
   /**
    * An arbitrary implementation for string buffer values.
    */
-  public static final Arbitrary<StringBuffer> arbStringBuffer =
-      arbitrary(arbString.gen.map(StringBuffer::new));
+  public static final Gen<StringBuffer> arbStringBuffer =
+      arbString.map(StringBuffer::new);
 
   /**
    * An arbitrary implementation for string builder values.
    */
-  public static final Arbitrary<StringBuilder> arbStringBuilder =
-      arbitrary(arbString.gen.map(StringBuilder::new));
+  public static final Gen<StringBuilder> arbStringBuilder =
+      arbString.map(StringBuilder::new);
 
   /**
    * Returns an arbitrary implementation for generators.
@@ -602,13 +580,13 @@ public Gen<Float> f(final Integer i) {
    * @param aa an arbitrary implementation for the type over which the generator is defined.
    * @return An arbitrary implementation for generators.
    */
-  public static <A> Arbitrary<Gen<A>> arbGen(final Arbitrary<A> aa) {
-    return arbitrary(sized(i -> {
+  public static <A> Gen<Gen<A>> arbGen(final Gen<A> aa) {
+    return sized(i -> {
       if (i == 0)
         return fail();
       else
-        return aa.gen.map(Gen::value).resize(i - 1);
-    }));
+        return aa.map(Gen::value).resize(i - 1);
+    });
   }
 
   /**
@@ -617,10 +595,10 @@ public static <A> Arbitrary<Gen<A>> arbGen(final Arbitrary<A> aa) {
    * @param aa an arbitrary implementation for the type over which the optional value is defined.
    * @return An arbitrary implementation for optional values.
    */
-  public static <A> Arbitrary<Option<A>> arbOption(final Arbitrary<A> aa) {
-    return arbitrary(sized(i -> i == 0 ?
+  public static <A> Gen<Option<A>> arbOption(final Gen<A> aa) {
+    return sized(i -> i == 0 ?
            value(Option.none()) :
-           aa.gen.map(Option::some).resize(i - 1)));
+           aa.map(Option::some).resize(i - 1));
   }
 
   /**
@@ -633,10 +611,10 @@ public static <A> Arbitrary<Option<A>> arbOption(final Arbitrary<A> aa) {
    * @return An arbitrary implementation for the disjoint union.
    */
   @SuppressWarnings("unchecked")
-  public static <A, B> Arbitrary<Either<A, B>> arbEither(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-    final Gen<Either<A, B>> left = aa.gen.map(Either::left);
-    final Gen<Either<A, B>> right = ab.gen.map(Either::right);
-    return arbitrary(oneOf(list(left, right)));
+  public static <A, B> Gen<Either<A, B>> arbEither(final Gen<A> aa, final Gen<B> ab) {
+    final Gen<Either<A, B>> left = aa.map(Either::left);
+    final Gen<Either<A, B>> right = ab.map(Either::right);
+    return oneOf(list(left, right));
   }
 
   /**
@@ -645,47 +623,47 @@ public static <A, B> Arbitrary<Either<A, B>> arbEither(final Arbitrary<A> aa, fi
    * @param aa An arbitrary implementation for the type over which the list is defined.
    * @return An arbitrary implementation for lists.
    */
-  public static <A> Arbitrary<List<A>> arbList(final Arbitrary<A> aa) {
-    return arbitrary(listOf(aa.gen));
+  public static <A> Gen<List<A>> arbList(final Gen<A> aa) {
+    return listOf(aa);
   }
 
 	/**
 	 * Returns an arbitrary list of integers.
 	 */
-	public static <A> Arbitrary<List<Integer>> arbListInteger() {
-		return arbitrary(listOf(arbInteger.gen));
+	public static <A> Gen<List<Integer>> arbListInteger() {
+		return listOf(arbInteger);
 	}
 
 	/**
 	 * Returns an arbitrary list of strings.
 	 */
-	public static <A> Arbitrary<List<String>> arbListString() {
-		return arbitrary(listOf(arbString.gen));
+	public static <A> Gen<List<String>> arbListString() {
+		return listOf(arbString);
 	}
 
 	/**
 	 * Returns an arbitrary list of booleans.
 	 */
-	public static <A> Arbitrary<List<Boolean>> arbListBoolean() {
-		return arbitrary(listOf(arbBoolean.gen));
+	public static <A> Gen<List<Boolean>> arbListBoolean() {
+		return listOf(arbBoolean);
 	}
 
 	/**
 	 * Returns an arbitrary list of doubles.
 	 */
-	public static <A> Arbitrary<List<Double>> arbListDouble() {
-		return arbitrary(listOf(arbDouble.gen));
+	public static <A> Gen<List<Double>> arbListDouble() {
+		return listOf(arbDouble);
 	}
 
-	public static <A> Arbitrary<NonEmptyList<A>> arbNonEmptyList(final Arbitrary<A> aa) {
-    return arbitrary(Gen.listOf1(aa.gen).map(list -> NonEmptyList.fromList(list).some()));
+	public static <A> Gen<NonEmptyList<A>> arbNonEmptyList(final Gen<A> aa) {
+    return Gen.listOf1(aa).map(list -> NonEmptyList.fromList(list).some());
   }
 
     /**
      * Returns an arbitrary Validation for the given arbitrary parameters.
      */
-    public static <A, B> Arbitrary<Validation<A, B>> arbValidation(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-        return arbitrary(arbBoolean.gen.bind(bool -> bool ? ab.gen.map(Validation::<A, B>success) : aa.gen.map(Validation::<A, B>fail)));
+    public static <A, B> Gen<Validation<A, B>> arbValidation(final Gen<A> aa, final Gen<B> ab) {
+        return arbBoolean.bind(bool -> bool ? ab.map(Validation::<A, B>success) : aa.map(Validation::<A, B>fail));
     }
 
   /**
@@ -694,8 +672,8 @@ public static <A, B> Arbitrary<Validation<A, B>> arbValidation(final Arbitrary<A
    * @param aa An arbitrary implementation for the type over which the stream is defined.
    * @return An arbitrary implementation for streams.
    */
-  public static <A> Arbitrary<Stream<A>> arbStream(final Arbitrary<A> aa) {
-    return arbitrary(arbList(aa).gen.map(List::toStream));
+  public static <A> Gen<Stream<A>> arbStream(final Gen<A> aa) {
+    return arbList(aa).map(List::toStream);
   }
 
   /**
@@ -704,8 +682,8 @@ public static <A> Arbitrary<Stream<A>> arbStream(final Arbitrary<A> aa) {
    * @param aa An arbitrary implementation for the type over which the array is defined.
    * @return An arbitrary implementation for arrays.
    */
-  public static <A> Arbitrary<Array<A>> arbArray(final Arbitrary<A> aa) {
-    return arbitrary(arbList(aa).gen.map(List<A>::toArray));
+  public static <A> Gen<Array<A>> arbArray(final Gen<A> aa) {
+    return arbList(aa).map(List<A>::toArray);
   }
 
   /**
@@ -715,17 +693,16 @@ public static <A> Arbitrary<Array<A>> arbArray(final Arbitrary<A> aa) {
    * @return An arbitrary implementation for sequences.
    */
   @SuppressWarnings("unchecked")
-  public static <A> Arbitrary<Seq<A>> arbSeq(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(Seq::iterableSeq));
+  public static <A> Gen<Seq<A>> arbSeq(final Gen<A> aa) {
+    return arbArray(aa).map(Seq::iterableSeq);
   }
 
-	public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa) {
-		return arbitrary(arbList(aa).gen.map(list -> Set.iterableSet(ord, list)));
+	public static <A> Gen<Set<A>> arbSet(Ord<A> ord, final Gen<A> aa) {
+		return arbList(aa).map(list -> Set.iterableSet(ord, list));
 	}
 
-    public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa, int max) {
-        Gen<Set<A>> g = choose(0, max).bind(i -> Gen.sequenceN(i, aa.gen)).map(list -> Set.iterableSet(ord, list));
-        return arbitrary(g);
+    public static <A> Gen<Set<A>> arbSet(Ord<A> ord, final Gen<A> aa, int max) {
+        return choose(0, max).bind(i -> Gen.sequenceN(i, aa)).map(list -> Set.iterableSet(ord, list));
     }
 
 
@@ -735,14 +712,14 @@ public static <A> Arbitrary<Set<A>> arbSet(Ord<A> ord, final Arbitrary<A> aa, in
    * @param as An arbitrary used for the throwable message.
    * @return An arbitrary implementation for throwables.
    */
-  public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
-    return arbitrary(as.gen.map(Throwable::new));
+  public static Gen<Throwable> arbThrowable(final Gen<String> as) {
+    return as.map(Throwable::new);
   }
 
   /**
    * An arbitrary implementation for throwables.
    */
-  public static final Arbitrary<Throwable> arbThrowable = arbThrowable(arbString);
+  public static final Gen<Throwable> arbThrowable = arbThrowable(arbString);
 
   // BEGIN java.util
 
@@ -752,33 +729,33 @@ public static Arbitrary<Throwable> arbThrowable(final Arbitrary<String> as) {
    * @param aa An arbitrary implementation for the type over which the array list is defined.
    * @return An arbitrary implementation for array lists.
    */
-  public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(Array::toJavaList));
+  public static <A> Gen<ArrayList<A>> arbArrayList(final Gen<A> aa) {
+    return arbArray(aa).map(Array::toJavaList);
   }
 
   /**
    * An arbitrary implementation for bit sets.
    */
-  public static final Arbitrary<BitSet> arbBitSet =
-      arbitrary(arbList(arbBoolean).gen.map(bs -> {
+  public static final Gen<BitSet> arbBitSet =
+      arbList(arbBoolean).map(bs -> {
         final BitSet s = new BitSet(bs.length());
         bs.zipIndex().foreachDoEffect(bi -> s.set(bi._2(), bi._1()));
         return s;
-      }));
+      });
 
   /**
    * An arbitrary implementation for calendars.
    */
-  public static final Arbitrary<Calendar> arbCalendar = arbitrary(arbLong.gen.map(i -> {
+  public static final Gen<Calendar> arbCalendar = arbLong.map(i -> {
     final Calendar c = Calendar.getInstance();
     c.setTimeInMillis(i);
     return c;
-  }));
+  });
 
   /**
    * An arbitrary implementation for dates.
    */
-  public static final Arbitrary<Date> arbDate = arbitrary(arbLong.gen.map(Date::new));
+  public static final Gen<Date> arbDate = arbLong.map(Date::new);
 
   /**
    * Returns an arbitrary implementation for a Java enumeration.
@@ -786,8 +763,8 @@ public static <A> Arbitrary<ArrayList<A>> arbArrayList(final Arbitrary<A> aa) {
    * @param clazz The type of enum to return an arbtrary of.
    * @return An arbitrary for instances of the supplied enum type.
    */
-  public static <A extends Enum<A>> Arbitrary<A> arbEnumValue(final Class<A> clazz) {
-    return arbitrary(elements(clazz.getEnumConstants()));
+  public static <A extends Enum<A>> Gen<A> arbEnumValue(final Class<A> clazz) {
+    return elements(clazz.getEnumConstants());
   }
 
   /**
@@ -798,9 +775,9 @@ public static <A extends Enum<A>> Arbitrary<A> arbEnumValue(final Class<A> clazz
    *           defined.
    * @return An arbitrary implementation for enum maps.
    */
-  public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final Arbitrary<K> ak,
-                                                                           final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(EnumMap::new));
+  public static <K extends Enum<K>, V> Gen<EnumMap<K, V>> arbEnumMap(final Gen<K> ak,
+                                                                           final Gen<V> av) {
+    return arbHashtable(ak, av).map(EnumMap::new);
   }
 
   /**
@@ -809,19 +786,19 @@ public static <K extends Enum<K>, V> Arbitrary<EnumMap<K, V>> arbEnumMap(final A
    * @param aa An arbitrary implementation for the type over which the enum set is defined.
    * @return An arbitrary implementation for enum sets.
    */
-  public static <A extends Enum<A>> Arbitrary<EnumSet<A>> arbEnumSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> copyOf(a.asJavaList())));
+  public static <A extends Enum<A>> Gen<EnumSet<A>> arbEnumSet(final Gen<A> aa) {
+    return arbArray(aa).map(a -> copyOf(a.asJavaList()));
   }
 
   /**
    * An arbitrary implementation for gregorian calendars.
    */
-  public static final Arbitrary<GregorianCalendar> arbGregorianCalendar =
-      arbitrary(arbLong.gen.map(i -> {
+  public static final Gen<GregorianCalendar> arbGregorianCalendar =
+      arbLong.map(i -> {
         final GregorianCalendar c = new GregorianCalendar();
         c.setTimeInMillis(i);
         return c;
-      }));
+      });
 
   /**
    * Returns an arbitrary implementation for hash maps.
@@ -831,8 +808,8 @@ public static <A extends Enum<A>> Arbitrary<EnumSet<A>> arbEnumSet(final Arbitra
    *           defined.
    * @return An arbitrary implementation for hash maps.
    */
-  public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(HashMap::new));
+  public static <K, V> Gen<HashMap<K, V>> arbHashMap(final Gen<K> ak, final Gen<V> av) {
+    return arbHashtable(ak, av).map(HashMap::new);
   }
 
   /**
@@ -841,8 +818,8 @@ public static <K, V> Arbitrary<HashMap<K, V>> arbHashMap(final Arbitrary<K> ak,
    * @param aa An arbitrary implementation for the type over which the hash set is defined.
    * @return An arbitrary implementation for hash sets.
    */
-  public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new HashSet<>(a.asJavaList())));
+  public static <A> Gen<HashSet<A>> arbHashSet(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new HashSet<>(a.asJavaList()));
   }
 
   /**
@@ -854,14 +831,14 @@ public static <A> Arbitrary<HashSet<A>> arbHashSet(final Arbitrary<A> aa) {
    *           defined.
    * @return An arbitrary implementation for hash tables.
    */
-  public static <K, V> Arbitrary<Hashtable<K, V>> arbHashtable(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbList(ak).gen.bind(arbList(av).gen, ks -> vs -> {
+  public static <K, V> Gen<Hashtable<K, V>> arbHashtable(final Gen<K> ak, final Gen<V> av) {
+    return arbList(ak).bind(arbList(av), ks -> vs -> {
       final Hashtable<K, V> t = new Hashtable<>();
 
       ks.zip(vs).foreachDoEffect(kv -> t.put(kv._1(), kv._2()));
 
       return t;
-    }));
+    });
   }
 
   /**
@@ -873,9 +850,9 @@ public static <K, V> Arbitrary<Hashtable<K, V>> arbHashtable(final Arbitrary<K>
    *           are defined.
    * @return An arbitrary implementation for identity hash maps.
    */
-  public static <K, V> Arbitrary<IdentityHashMap<K, V>> arbIdentityHashMap(final Arbitrary<K> ak,
-                                                                           final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(IdentityHashMap::new));
+  public static <K, V> Gen<IdentityHashMap<K, V>> arbIdentityHashMap(final Gen<K> ak,
+                                                                           final Gen<V> av) {
+    return arbHashtable(ak, av).map(IdentityHashMap::new);
   }
 
   /**
@@ -887,8 +864,8 @@ public static <K, V> Arbitrary<IdentityHashMap<K, V>> arbIdentityHashMap(final A
    *           defined.
    * @return An arbitrary implementation for linked hash maps.
    */
-  public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(LinkedHashMap::new));
+  public static <K, V> Gen<LinkedHashMap<K, V>> arbLinkedHashMap(final Gen<K> ak, final Gen<V> av) {
+    return arbHashtable(ak, av).map(LinkedHashMap::new);
   }
 
   /**
@@ -897,8 +874,8 @@ public static <K, V> Arbitrary<LinkedHashMap<K, V>> arbLinkedHashMap(final Arbit
    * @param aa An arbitrary implementation for the type over which the hash set is defined.
    * @return An arbitrary implementation for hash sets.
    */
-  public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedHashSet<>(a.asJavaList())));
+  public static <A> Gen<LinkedHashSet<A>> arbLinkedHashSet(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new LinkedHashSet<>(a.asJavaList()));
   }
 
   /**
@@ -907,8 +884,8 @@ public static <A> Arbitrary<LinkedHashSet<A>> arbLinkedHashSet(final Arbitrary<A
    * @param aa An arbitrary implementation for the type over which the linked list is defined.
    * @return An arbitrary implementation for linked lists.
    */
-  public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedList<>(a.asJavaList())));
+  public static <A> Gen<LinkedList<A>> arbLinkedList(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new LinkedList<>(a.asJavaList()));
   }
 
   /**
@@ -917,15 +894,15 @@ public static <A> Arbitrary<LinkedList<A>> arbLinkedList(final Arbitrary<A> aa)
    * @param aa An arbitrary implementation for the type over which the priority queue is defined.
    * @return An arbitrary implementation for priority queues.
    */
-  public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityQueue<>(a.asJavaList())));
+  public static <A> Gen<PriorityQueue<A>> arbPriorityQueue(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new PriorityQueue<>(a.asJavaList()));
   }
 
   /**
    * An arbitrary implementation for properties.
    */
-  public static final Arbitrary<Properties> arbProperties =
-      arbitrary(arbHashtable(arbString, arbString).gen.map(ht -> {
+  public static final Gen<Properties> arbProperties =
+      arbHashtable(arbString, arbString).map(ht -> {
         final Properties p = new Properties();
 
         for (final Map.Entry<String, String> entry : ht.entrySet()) {
@@ -933,7 +910,7 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
         }
 
         return p;
-      }));
+      });
 
   /**
    * Returns an arbitrary implementation for stacks.
@@ -941,12 +918,12 @@ public static <A> Arbitrary<PriorityQueue<A>> arbPriorityQueue(final Arbitrary<A
    * @param aa An arbitrary implementation for the type over which the stack is defined.
    * @return An arbitrary implementation for stacks.
    */
-  public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> {
+  public static <A> Gen<Stack<A>> arbStack(final Gen<A> aa) {
+    return arbArray(aa).map(a -> {
       final Stack<A> s = new Stack<>();
       s.addAll(a.asJavaList());
       return s;
-    }));
+    });
   }
 
   /**
@@ -957,45 +934,45 @@ public static <A> Arbitrary<Stack<A>> arbStack(final Arbitrary<A> aa) {
    *           defined.
    * @return An arbitrary implementation for tree maps.
    */
-  public static <K, V> Arbitrary<java.util.TreeMap<K, V>> arbJavaTreeMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(java.util.TreeMap::new));
+  public static <K, V> Gen<java.util.TreeMap<K, V>> arbJavaTreeMap(final Gen<K> ak, final Gen<V> av) {
+    return arbHashtable(ak, av).map(java.util.TreeMap::new);
   }
 
     /**
      * Returns an arbitrary implementation for tree maps.
      */
-    public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<List<P2<K, V>>> al) {
-        return arbitrary(al.gen.map(list -> fj.data.TreeMap.iterableTreeMap(ord, list)));
+    public static <K, V> Gen<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Gen<List<P2<K, V>>> al) {
+        return al.map(list -> fj.data.TreeMap.iterableTreeMap(ord, list));
     }
 
     /**
      * Returns an arbitrary implementation for tree maps.
      */
-    public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<K> ak, Arbitrary<V> av) {
+    public static <K, V> Gen<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Gen<K> ak, Gen<V> av) {
         return arbTreeMap(ord, arbList(arbP2(ak, av)));
     }
 
     /**
      * Returns an arbitrary implementation for tree maps where the map size is the given arbitrary integer.
      */
-    public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<K> ak, Arbitrary<V> av, Arbitrary<Integer> ai) {
-        Gen<List<P2<K, V>>> gl2 = ai.gen.bind(i -> {
+    public static <K, V> Gen<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Gen<K> ak, Gen<V> av, Gen<Integer> ai) {
+        Gen<List<P2<K, V>>> gl2 = ai.bind(i -> {
             if (i < 0) {
                 throw Bottom.error("Undefined: arbitrary natural is negative (" + i + ")");
             }
-            return Gen.sequenceN(Math.max(i, 0), arbP2(ak, av).gen);
+            return Gen.sequenceN(Math.max(i, 0), arbP2(ak, av));
         });
-        return arbTreeMap(ord, arbitrary(gl2));
+        return arbTreeMap(ord, gl2);
     }
 
     /**
      * Returns an arbitrary implementation for tree maps where the size is less than or equal to the max size.
      */
-    public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arbitrary<K> ak, Arbitrary<V> av, int maxSize) {
+    public static <K, V> Gen<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Gen<K> ak, Gen<V> av, int maxSize) {
         if (maxSize < 0) {
           throw Bottom.error("Undefined: arbitrary natural is negative (" + maxSize + ")");
         }
-        return arbTreeMap(ord, ak, av, arbitrary(choose(0, maxSize)));
+        return arbTreeMap(ord, ak, av, choose(0, maxSize));
     }
 
   /**
@@ -1004,8 +981,8 @@ public static <K, V> Arbitrary<fj.data.TreeMap<K, V>> arbTreeMap(Ord<K> ord, Arb
    * @param aa An arbitrary implementation for the type over which the tree set is defined.
    * @return An arbitrary implementation for tree sets.
    */
-  public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new TreeSet<>(a.asJavaList())));
+  public static <A> Gen<TreeSet<A>> arbTreeSet(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new TreeSet<>(a.asJavaList()));
   }
 
   /**
@@ -1015,8 +992,8 @@ public static <A> Arbitrary<TreeSet<A>> arbTreeSet(final Arbitrary<A> aa) {
    * @return An arbitrary implementation for vectors.
    */
   @SuppressWarnings("UseOfObsoleteCollectionType")
-  public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new Vector<>(a.asJavaList())));
+  public static <A> Gen<Vector<A>> arbVector(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new Vector<>(a.asJavaList()));
   }
 
   /**
@@ -1028,8 +1005,8 @@ public static <A> Arbitrary<Vector<A>> arbVector(final Arbitrary<A> aa) {
    *           defined.
    * @return An arbitrary implementation for weak hash maps.
    */
-  public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary<K> ak, final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(WeakHashMap::new));
+  public static <K, V> Gen<WeakHashMap<K, V>> arbWeakHashMap(final Gen<K> ak, final Gen<V> av) {
+    return arbHashtable(ak, av).map(WeakHashMap::new);
   }
 
   // END java.util
@@ -1043,10 +1020,10 @@ public static <K, V> Arbitrary<WeakHashMap<K, V>> arbWeakHashMap(final Arbitrary
    *           defined.
    * @return An arbitrary implementation for array blocking queues.
    */
-  public static <A> Arbitrary<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.bind(arbInteger.gen, arbBoolean.gen,
+  public static <A> Gen<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Gen<A> aa) {
+    return arbArray(aa).bind(arbInteger, arbBoolean,
         a -> capacity -> fair -> new ArrayBlockingQueue<A>(a.length() + abs(capacity),
-                                         fair, a.asJavaList())));
+                                         fair, a.asJavaList()));
   }
 
   /**
@@ -1058,9 +1035,9 @@ public static <A> Arbitrary<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final A
    *           are defined.
    * @return An arbitrary implementation for concurrent hash maps.
    */
-  public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(final Arbitrary<K> ak,
-                                                                               final Arbitrary<V> av) {
-    return arbitrary(arbHashtable(ak, av).gen.map(ConcurrentHashMap::new));
+  public static <K, V> Gen<ConcurrentHashMap<K, V>> arbConcurrentHashMap(final Gen<K> ak,
+                                                                               final Gen<V> av) {
+    return arbHashtable(ak, av).map(ConcurrentHashMap::new);
   }
 
   /**
@@ -1070,8 +1047,8 @@ public static <K, V> Arbitrary<ConcurrentHashMap<K, V>> arbConcurrentHashMap(fin
    *           defined.
    * @return An arbitrary implementation for concurrent linked queues.
    */
-  public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new ConcurrentLinkedQueue<>(a.asJavaList())));
+  public static <A> Gen<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new ConcurrentLinkedQueue<>(a.asJavaList()));
   }
 
   /**
@@ -1081,8 +1058,8 @@ public static <A> Arbitrary<ConcurrentLinkedQueue<A>> arbConcurrentLinkedQueue(f
    *           defined.
    * @return An arbitrary implementation for copy-on-write array lists.
    */
-  public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArrayList<>(a.asJavaList())));
+  public static <A> Gen<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new CopyOnWriteArrayList<>(a.asJavaList()));
   }
 
   /**
@@ -1092,8 +1069,8 @@ public static <A> Arbitrary<CopyOnWriteArrayList<A>> arbCopyOnWriteArrayList(fin
    *           defined.
    * @return An arbitrary implementation for copy-on-write array sets.
    */
-  public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new CopyOnWriteArraySet<>(a.asJavaList())));
+  public static <A> Gen<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new CopyOnWriteArraySet<>(a.asJavaList()));
   }
 
   /**
@@ -1102,8 +1079,8 @@ public static <A> Arbitrary<CopyOnWriteArraySet<A>> arbCopyOnWriteArraySet(final
    * @param aa An arbitrary implementation for the type over which the delay queue is defined.
    * @return An arbitrary implementation for delay queues.
    */
-  public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new DelayQueue<>(a.asJavaList())));
+  public static <A extends Delayed> Gen<DelayQueue<A>> arbDelayQueue(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new DelayQueue<>(a.asJavaList()));
   }
 
   /**
@@ -1113,8 +1090,8 @@ public static <A extends Delayed> Arbitrary<DelayQueue<A>> arbDelayQueue(final A
    *           defined.
    * @return An arbitrary implementation for linked blocking queues.
    */
-  public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new LinkedBlockingQueue<>(a.asJavaList())));
+  public static <A> Gen<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new LinkedBlockingQueue<>(a.asJavaList()));
   }
 
   /**
@@ -1124,8 +1101,8 @@ public static <A> Arbitrary<LinkedBlockingQueue<A>> arbLinkedBlockingQueue(final
    *           defined.
    * @return An arbitrary implementation for priority blocking queues.
    */
-  public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.map(a -> new PriorityBlockingQueue<>(a.asJavaList())));
+  public static <A> Gen<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(final Gen<A> aa) {
+    return arbArray(aa).map(a -> new PriorityBlockingQueue<>(a.asJavaList()));
   }
 
   /**
@@ -1135,12 +1112,12 @@ public static <A> Arbitrary<PriorityBlockingQueue<A>> arbPriorityBlockingQueue(f
    *           defined.
    * @return An arbitrary implementation for priority blocking queues.
    */
-  public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbitrary<A> aa) {
-    return arbitrary(arbArray(aa).gen.bind(arbBoolean.gen, a -> fair -> {
+  public static <A> Gen<SynchronousQueue<A>> arbSynchronousQueue(final Gen<A> aa) {
+    return arbArray(aa).bind(arbBoolean, a -> fair -> {
       final SynchronousQueue<A> q = new SynchronousQueue<>(fair);
       q.addAll(a.asJavaList());
       return q;
-    }));
+    });
   }
 
   // END java.util.concurrent
@@ -1150,17 +1127,17 @@ public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbit
   /**
    * An arbitrary implementation for SQL dates.
    */
-  public static final Arbitrary<java.sql.Date> arbSQLDate = arbitrary(arbLong.gen.map(java.sql.Date::new));
+  public static final Gen<java.sql.Date> arbSQLDate = arbLong.map(java.sql.Date::new);
 
   /**
    * An arbitrary implementation for SQL times.
    */
-  public static final Arbitrary<Time> arbTime = arbitrary(arbLong.gen.map(Time::new));
+  public static final Gen<Time> arbTime = arbLong.map(Time::new);
 
   /**
    * An arbitrary implementation for SQL time stamps.
    */
-  public static final Arbitrary<Timestamp> arbTimestamp = arbitrary(arbLong.gen.map(Timestamp::new));
+  public static final Gen<Timestamp> arbTimestamp = arbLong.map(Timestamp::new);
 
   // END java.sql
 
@@ -1169,8 +1146,8 @@ public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbit
   /**
    * An arbitrary implementation for big integers.
    */
-  public static final Arbitrary<BigInteger> arbBigInteger =
-      arbitrary(arbArray(arbByte).gen.bind(arbByte.gen, a -> b -> {
+  public static final Gen<BigInteger> arbBigInteger =
+      arbArray(arbByte).bind(arbByte, a -> b -> {
         final byte[] x = new byte[a.length() + 1];
 
         for (int i = 0; i < a.array().length; i++) {
@@ -1180,20 +1157,20 @@ public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbit
         x[a.length()] = b;
 
         return new BigInteger(x);
-      }));
+      });
 
   /**
    * An arbitrary implementation for big decimals.
    */
-  public static final Arbitrary<BigDecimal> arbBigDecimal =
-      arbitrary(arbBigInteger.gen.map(BigDecimal::new));
+  public static final Gen<BigDecimal> arbBigDecimal =
+      arbBigInteger.map(BigDecimal::new);
 
   // END java.math
 
   /**
    * An arbitrary implementation for locales.
    */
-  public static final Arbitrary<Locale> arbLocale = arbitrary(elements(getAvailableLocales()));
+  public static final Gen<Locale> arbLocale = elements(getAvailableLocales());
 
   /**
    * Returns an arbitrary implementation for product-1 values.
@@ -1201,8 +1178,8 @@ public static <A> Arbitrary<SynchronousQueue<A>> arbSynchronousQueue(final Arbit
    * @param aa An arbitrary implementation for the type over which the product-1 is defined.
    * @return An arbitrary implementation for product-1 values.
    */
-  public static <A> Arbitrary<P1<A>> arbP1(final Arbitrary<A> aa) {
-    return arbitrary(aa.gen.map(P::p));
+  public static <A> Gen<P1<A>> arbP1(final Gen<A> aa) {
+    return aa.map(P::p);
   }
 
   /**
@@ -1214,8 +1191,8 @@ public static <A> Arbitrary<P1<A>> arbP1(final Arbitrary<A> aa) {
    *           defined.
    * @return An arbitrary implementation for product-2 values.
    */
-  public static <A, B> Arbitrary<P2<A, B>> arbP2(final Arbitrary<A> aa, final Arbitrary<B> ab) {
-    return arbitrary(aa.gen.bind(ab.gen, a -> b -> p(a, b)));
+  public static <A, B> Gen<P2<A, B>> arbP2(final Gen<A> aa, final Gen<B> ab) {
+    return aa.bind(ab, a -> b -> p(a, b));
   }
 
   /**
@@ -1229,9 +1206,9 @@ public static <A, B> Arbitrary<P2<A, B>> arbP2(final Arbitrary<A> aa, final Arbi
    *           defined.
    * @return An arbitrary implementation for product-3 values.
    */
-  public static <A, B, C> Arbitrary<P3<A, B, C>> arbP3(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                       final Arbitrary<C> ac) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, a -> b -> c -> p(a, b, c)));
+  public static <A, B, C> Gen<P3<A, B, C>> arbP3(final Gen<A> aa, final Gen<B> ab,
+                                                 final Gen<C> ac) {
+    return aa.bind(ab, ac, a -> b -> c -> p(a, b, c));
   }
 
   /**
@@ -1247,9 +1224,9 @@ public static <A, B, C> Arbitrary<P3<A, B, C>> arbP3(final Arbitrary<A> aa, fina
    *           defined.
    * @return An arbitrary implementation for product-4 values.
    */
-  public static <A, B, C, D> Arbitrary<P4<A, B, C, D>> arbP4(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                             final Arbitrary<C> ac, final Arbitrary<D> ad) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, a -> b -> c -> d -> p(a, b, c, d)));
+  public static <A, B, C, D> Gen<P4<A, B, C, D>> arbP4(final Gen<A> aa, final Gen<B> ab,
+                                                       final Gen<C> ac, final Gen<D> ad) {
+    return aa.bind(ab, ac, ad, a -> b -> c -> d -> p(a, b, c, d));
   }
 
   /**
@@ -1267,10 +1244,10 @@ public static <A, B, C, D> Arbitrary<P4<A, B, C, D>> arbP4(final Arbitrary<A> aa
    *           defined.
    * @return An arbitrary implementation for product-5 values.
    */
-  public static <A, B, C, D, E> Arbitrary<P5<A, B, C, D, E>> arbP5(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                                   final Arbitrary<C> ac, final Arbitrary<D> ad,
-                                                                   final Arbitrary<E> ae) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, a -> b -> c -> d -> e -> p(a, b, c, d, e)));
+  public static <A, B, C, D, E> Gen<P5<A, B, C, D, E>> arbP5(final Gen<A> aa, final Gen<B> ab,
+                                                             final Gen<C> ac, final Gen<D> ad,
+                                                             final Gen<E> ae) {
+    return aa.bind(ab, ac, ad, ae, a -> b -> c -> d -> e -> p(a, b, c, d, e));
   }
 
   /**
@@ -1290,12 +1267,12 @@ public static <A, B, C, D, E> Arbitrary<P5<A, B, C, D, E>> arbP5(final Arbitrary
    *           defined.
    * @return An arbitrary implementation for product-6 values.
    */
-  public static <A, B, C, D, E, F$> Arbitrary<P6<A, B, C, D, E, F$>> arbP6(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                                           final Arbitrary<C> ac, final Arbitrary<D> ad,
-                                                                           final Arbitrary<E> ae,
-                                                                           final Arbitrary<F$> af) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen,
-        a -> b -> c -> d -> e -> f -> p(a, b, c, d, e, f)));
+  public static <A, B, C, D, E, F$> Gen<P6<A, B, C, D, E, F$>> arbP6(final Gen<A> aa, final Gen<B> ab,
+                                                                     final Gen<C> ac, final Gen<D> ad,
+                                                                     final Gen<E> ae,
+                                                                     final Gen<F$> af) {
+    return aa.bind(ab, ac, ad, ae, af,
+        a -> b -> c -> d -> e -> f -> p(a, b, c, d, e, f));
   }
 
   /**
@@ -1317,15 +1294,15 @@ public static <A, B, C, D, E> Arbitrary<P5<A, B, C, D, E>> arbP5(final Arbitrary
    *           defined.
    * @return An arbitrary implementation for product-7 values.
    */
-  public static <A, B, C, D, E, F$, G> Arbitrary<P7<A, B, C, D, E, F$, G>> arbP7(final Arbitrary<A> aa,
-                                                                                 final Arbitrary<B> ab,
-                                                                                 final Arbitrary<C> ac,
-                                                                                 final Arbitrary<D> ad,
-                                                                                 final Arbitrary<E> ae,
-                                                                                 final Arbitrary<F$> af,
-                                                                                 final Arbitrary<G> ag) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen, ag.gen,
-        a -> b -> c -> d -> e -> f -> g -> p(a, b, c, d, e, f, g)));
+  public static <A, B, C, D, E, F$, G> Gen<P7<A, B, C, D, E, F$, G>> arbP7(final Gen<A> aa,
+                                                                           final Gen<B> ab,
+                                                                           final Gen<C> ac,
+                                                                           final Gen<D> ad,
+                                                                           final Gen<E> ae,
+                                                                           final Gen<F$> af,
+                                                                           final Gen<G> ag) {
+    return aa.bind(ab, ac, ad, ae, af, ag,
+        a -> b -> c -> d -> e -> f -> g -> p(a, b, c, d, e, f, g));
   }
 
   /**
@@ -1349,15 +1326,15 @@ public static <A, B, C, D, E> Arbitrary<P5<A, B, C, D, E>> arbP5(final Arbitrary
    *           defined.
    * @return An arbitrary implementation for product-8 values.
    */
-  public static <A, B, C, D, E, F$, G, H> Arbitrary<P8<A, B, C, D, E, F$, G, H>> arbP8(final Arbitrary<A> aa,
-                                                                                       final Arbitrary<B> ab,
-                                                                                       final Arbitrary<C> ac,
-                                                                                       final Arbitrary<D> ad,
-                                                                                       final Arbitrary<E> ae,
-                                                                                       final Arbitrary<F$> af,
-                                                                                       final Arbitrary<G> ag,
-                                                                                       final Arbitrary<H> ah) {
-    return arbitrary(aa.gen.bind(ab.gen, ac.gen, ad.gen, ae.gen, af.gen, ag.gen, ah.gen,
-        a -> b -> c -> d -> e -> f -> g -> h -> p(a, b, c, d, e, f, g, h)));
+  public static <A, B, C, D, E, F$, G, H> Gen<P8<A, B, C, D, E, F$, G, H>> arbP8(final Gen<A> aa,
+                                                                                 final Gen<B> ab,
+                                                                                 final Gen<C> ac,
+                                                                                 final Gen<D> ad,
+                                                                                 final Gen<E> ae,
+                                                                                 final Gen<F$> af,
+                                                                                 final Gen<G> ag,
+                                                                                 final Gen<H> ah) {
+    return aa.bind(ab, ac, ad, ae, af, ag, ah,
+        a -> b -> c -> d -> e -> f -> g -> h -> p(a, b, c, d, e, f, g, h));
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
index d158a90f..14c7acb4 100644
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Coarbitrary.java
@@ -116,10 +116,10 @@ public <X> Gen<X> coarbitrary(final B b, final Gen<X> g) {
    * @param c A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function.
    */
-  public static <A, B> Coarbitrary<F<A, B>> coarbF(final Arbitrary<A> a, final Coarbitrary<B> c) {
+  public static <A, B> Coarbitrary<F<A, B>> coarbF(final Gen<A> a, final Coarbitrary<B> c) {
     return new Coarbitrary<F<A, B>>() {
       public <X> Gen<X> coarbitrary(final F<A, B> f, final Gen<X> g) {
-        return a.gen.bind(a1 -> c.coarbitrary(f.f(a1), g));
+        return a.bind(a1 -> c.coarbitrary(f.f(a1), g));
       }
     };
   }
@@ -132,7 +132,7 @@ public <X> Gen<X> coarbitrary(final F<A, B> f, final Gen<X> g) {
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-2.
    */
-  public static <A, B, C> Coarbitrary<F2<A, B, C>> coarbF2(final Arbitrary<A> aa, final Arbitrary<B> ab,
+  public static <A, B, C> Coarbitrary<F2<A, B, C>> coarbF2(final Gen<A> aa, final Gen<B> ab,
                                                            final Coarbitrary<C> c) {
     return new Coarbitrary<F2<A, B, C>>() {
       public <X> Gen<X> coarbitrary(final F2<A, B, C> f, final Gen<X> g) {
@@ -150,8 +150,8 @@ public <X> Gen<X> coarbitrary(final F2<A, B, C> f, final Gen<X> g) {
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-3.
    */
-  public static <A, B, C, D> Coarbitrary<F3<A, B, C, D>> coarbF3(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                                 final Arbitrary<C> ac, final Coarbitrary<D> c) {
+  public static <A, B, C, D> Coarbitrary<F3<A, B, C, D>> coarbF3(final Gen<A> aa, final Gen<B> ab,
+                                                                 final Gen<C> ac, final Coarbitrary<D> c) {
     return new Coarbitrary<F3<A, B, C, D>>() {
       public <X> Gen<X> coarbitrary(final F3<A, B, C, D> f, final Gen<X> g) {
         return coarbF(aa, coarbF(ab, coarbF(ac, c))).coarbitrary(curry(f), g);
@@ -169,8 +169,8 @@ public <X> Gen<X> coarbitrary(final F3<A, B, C, D> f, final Gen<X> g) {
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-4.
    */
-  public static <A, B, C, D, E> Coarbitrary<F4<A, B, C, D, E>> coarbF4(final Arbitrary<A> aa, final Arbitrary<B> ab,
-                                                                       final Arbitrary<C> ac, final Arbitrary<D> ad,
+  public static <A, B, C, D, E> Coarbitrary<F4<A, B, C, D, E>> coarbF4(final Gen<A> aa, final Gen<B> ab,
+                                                                       final Gen<C> ac, final Gen<D> ad,
                                                                        final Coarbitrary<E> c) {
     return new Coarbitrary<F4<A, B, C, D, E>>() {
       public <X> Gen<X> coarbitrary(final F4<A, B, C, D, E> f, final Gen<X> g) {
@@ -190,11 +190,11 @@ public <X> Gen<X> coarbitrary(final F4<A, B, C, D, E> f, final Gen<X> g) {
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-5.
    */
-  public static <A, B, C, D, E, F$> Coarbitrary<F5<A, B, C, D, E, F$>> coarbF5(final Arbitrary<A> aa,
-                                                                               final Arbitrary<B> ab,
-                                                                               final Arbitrary<C> ac,
-                                                                               final Arbitrary<D> ad,
-                                                                               final Arbitrary<E> ae,
+  public static <A, B, C, D, E, F$> Coarbitrary<F5<A, B, C, D, E, F$>> coarbF5(final Gen<A> aa,
+                                                                               final Gen<B> ab,
+                                                                               final Gen<C> ac,
+                                                                               final Gen<D> ad,
+                                                                               final Gen<E> ae,
                                                                                final Coarbitrary<F$> c) {
     return new Coarbitrary<F5<A, B, C, D, E, F$>>() {
       public <X> Gen<X> coarbitrary(final F5<A, B, C, D, E, F$> f, final Gen<X> g) {
@@ -215,12 +215,12 @@ public <X> Gen<X> coarbitrary(final F5<A, B, C, D, E, F$> f, final Gen<X> g) {
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-6.
    */
-  public static <A, B, C, D, E, F$, G> Coarbitrary<F6<A, B, C, D, E, F$, G>> coarbF6(final Arbitrary<A> aa,
-                                                                                     final Arbitrary<B> ab,
-                                                                                     final Arbitrary<C> ac,
-                                                                                     final Arbitrary<D> ad,
-                                                                                     final Arbitrary<E> ae,
-                                                                                     final Arbitrary<F$> af,
+  public static <A, B, C, D, E, F$, G> Coarbitrary<F6<A, B, C, D, E, F$, G>> coarbF6(final Gen<A> aa,
+                                                                                     final Gen<B> ab,
+                                                                                     final Gen<C> ac,
+                                                                                     final Gen<D> ad,
+                                                                                     final Gen<E> ae,
+                                                                                     final Gen<F$> af,
                                                                                      final Coarbitrary<G> c) {
     return new Coarbitrary<F6<A, B, C, D, E, F$, G>>() {
       public <X> Gen<X> coarbitrary(final F6<A, B, C, D, E, F$, G> f, final Gen<X> g) {
@@ -242,13 +242,13 @@ public <X> Gen<X> coarbitrary(final F6<A, B, C, D, E, F$, G> f, final Gen<X> g)
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-7.
    */
-  public static <A, B, C, D, E, F$, G, H> Coarbitrary<F7<A, B, C, D, E, F$, G, H>> coarbF7(final Arbitrary<A> aa,
-                                                                                           final Arbitrary<B> ab,
-                                                                                           final Arbitrary<C> ac,
-                                                                                           final Arbitrary<D> ad,
-                                                                                           final Arbitrary<E> ae,
-                                                                                           final Arbitrary<F$> af,
-                                                                                           final Arbitrary<G> ag,
+  public static <A, B, C, D, E, F$, G, H> Coarbitrary<F7<A, B, C, D, E, F$, G, H>> coarbF7(final Gen<A> aa,
+                                                                                           final Gen<B> ab,
+                                                                                           final Gen<C> ac,
+                                                                                           final Gen<D> ad,
+                                                                                           final Gen<E> ae,
+                                                                                           final Gen<F$> af,
+                                                                                           final Gen<G> ag,
                                                                                            final Coarbitrary<H> c) {
     return new Coarbitrary<F7<A, B, C, D, E, F$, G, H>>() {
       public <X> Gen<X> coarbitrary(final F7<A, B, C, D, E, F$, G, H> f, final Gen<X> g) {
@@ -272,14 +272,14 @@ public <X> Gen<X> coarbitrary(final F7<A, B, C, D, E, F$, G, H> f, final Gen<X>
    * @param c  A coarbitrary for the codomain of the function.
    * @return A coarbitrary for a function-8.
    */
-  public static <A, B, C, D, E, F$, G, H, I> Coarbitrary<F8<A, B, C, D, E, F$, G, H, I>> coarbF8(final Arbitrary<A> aa,
-                                                                                                 final Arbitrary<B> ab,
-                                                                                                 final Arbitrary<C> ac,
-                                                                                                 final Arbitrary<D> ad,
-                                                                                                 final Arbitrary<E> ae,
-                                                                                                 final Arbitrary<F$> af,
-                                                                                                 final Arbitrary<G> ag,
-                                                                                                 final Arbitrary<H> ah,
+  public static <A, B, C, D, E, F$, G, H, I> Coarbitrary<F8<A, B, C, D, E, F$, G, H, I>> coarbF8(final Gen<A> aa,
+                                                                                                 final Gen<B> ab,
+                                                                                                 final Gen<C> ac,
+                                                                                                 final Gen<D> ad,
+                                                                                                 final Gen<E> ae,
+                                                                                                 final Gen<F$> af,
+                                                                                                 final Gen<G> ag,
+                                                                                                 final Gen<H> ah,
                                                                                                  final Coarbitrary<I> c) {
     return new Coarbitrary<F8<A, B, C, D, E, F$, G, H, I>>() {
       public <X> Gen<X> coarbitrary(final F8<A, B, C, D, E, F$, G, H, I> f, final Gen<X> g) {
@@ -468,11 +468,11 @@ public <B> Gen<B> coarbitrary(LcgRng rng, Gen<B> g) {
   /**
    * A coarbitrary for state.
    */
-  public static <S, A> Coarbitrary<State<S, A>> coarbState(Arbitrary<S> as, F2<S, A, Long> f) {
+  public static <S, A> Coarbitrary<State<S, A>> coarbState(Gen<S> as, F2<S, A, Long> f) {
     return new Coarbitrary<State<S, A>>() {
       @Override
       public <B> Gen<B> coarbitrary(State<S, A> s1, Gen<B> g) {
-        return as.gen.bind(r -> {
+        return as.bind(r -> {
           P2<S, A> p = s1.run(r);
           return variant(f.f(p._1(), p._2()), g);
         });
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 6db7b304..1ea9be0a 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -50,21 +50,20 @@ class Person {
  * invoking the {@link #bind(F)}  methods &mdash; in this case, {@link #bind(Gen , Gen , F)} the one
  * that takes two generator arguments}, since the class has one more than two fields (the bind
  * method is invoked on a generator adding the extra one to the count as they are composed). The
- * class fields are of types for which there exist generators (on {@link Arbitrary} so those can be
+ * class fields are of types for which there exist generators (on {@link Gen} so those can be
  * used to compose a generator for <code>Person</code>: </p>
 <pre>
-static Arbitrary&lt;Person&gt; personArbitrary() {
-  final Gen&lt;Person&gt; personGenerator = arbInteger.gen.bind(arbString().gen, arbBoolean().gen,
+static Gen&lt;Person&gt; personArbitrary() {
+  return arbInteger.bind(arbString(), arbBoolean(),
       // compose the generators
       {int age =&gt; {String name =&gt; {boolean male =&gt; new Person(age, name, male)}}};
-  return arbitrary(personGenerator);
 }
 </pre>
  * <p/>
  * The example above uses Java 7 closure syntax. Here is the same example using objects instead:
 <pre>
-static Arbitrary&lt;Person&gt; personArbitrary() {
-  final Gen&lt;Person&gt; personGenerator = arbInteger.gen.bind(arbString.gen, arbBoolean.gen,
+static Gen&lt;Person&gt; personArbitrary() {
+  return arbInteger.bind(arbString, arbBoolean,
       // compose the generators
       new F&lt;Integer, F&lt;String, F&lt;Boolean, Person&gt;&gt;&gt;() {
         public F&lt;String, F&lt;Boolean, Person&gt;&gt; f(final Integer age) {
@@ -79,7 +78,6 @@ public Person f(final Boolean male) {
           };
         }
       });
-  return arbitrary(personGenerator);
 }
 </pre>
  *
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 274a7453..0f77f85e 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -443,8 +443,8 @@ public boolean failed(final Option<P2<A, Result>> o) {
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A> Property propertyP(final Arbitrary<A> aa, final Shrink<A> sa, final F<A, P1<Property>> f) {
-    return forall(aa.gen, sa, f);
+  public static <A> Property propertyP(final Gen<A> aa, final Shrink<A> sa, final F<A, P1<Property>> f) {
+    return forall(aa, sa, f);
   }
 
   /**
@@ -457,7 +457,7 @@ public static <A> Property propertyP(final Arbitrary<A> aa, final Shrink<A> sa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A> Property property(final Arbitrary<A> aa, final Shrink<A> sa, final F<A, Property> f) {
+  public static <A> Property property(final Gen<A> aa, final Shrink<A> sa, final F<A, Property> f) {
     return propertyP(aa, sa, P1.curry(f));
   }
 
@@ -470,7 +470,7 @@ public static <A> Property property(final Arbitrary<A> aa, final Shrink<A> sa, f
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A> Property propertyP(final Arbitrary<A> aa, final F<A, P1<Property>> f) {
+  public static <A> Property propertyP(final Gen<A> aa, final F<A, P1<Property>> f) {
     return propertyP(aa, Shrink.empty(), f);
   }
 
@@ -483,7 +483,7 @@ public static <A> Property propertyP(final Arbitrary<A> aa, final F<A, P1<Proper
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A> Property property(final Arbitrary<A> aa, final F<A, Property> f) {
+  public static <A> Property property(final Gen<A> aa, final F<A, Property> f) {
     return propertyP(aa, P1.curry(f));
   }
 
@@ -500,7 +500,7 @@ public static <A> Property property(final Arbitrary<A> aa, final F<A, Property>
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, P1<Property>>> f) {
+  public static <A, B> Property propertyP(final Gen<A> aa, final Gen<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, P1<Property>>> f) {
     return property(aa, sa, a -> {
       return propertyP(ab, sb, b -> {
         return f.f(a).f(b);
@@ -520,7 +520,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, Property>> f) {
+  public static <A, B> Property property(final Gen<A> aa, final Gen<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, Property>> f) {
     return propertyP(aa, ab, sa, sb, compose2(P.p1(), f));
   }
 
@@ -534,7 +534,7 @@ public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B>
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, P1<Property>>> f) {
+  public static <A, B> Property propertyP(final Gen<A> aa, final Gen<B> ab, final F<A, F<B, P1<Property>>> f) {
     return property(aa, a -> propertyP(ab, b -> f.f(a).f(b)));
   }
 
@@ -548,7 +548,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F<A, F<B, Property>> f) {
+  public static <A, B> Property property(final Gen<A> aa, final Gen<B> ab, final F<A, F<B, Property>> f) {
     return propertyP(aa, ab, compose2(P.p1(), f));
   }
 
@@ -564,7 +564,7 @@ public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B>
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, P1<Property>> f) {
+  public static <A, B> Property propertyP(final Gen<A> aa, final Gen<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, P1<Property>> f) {
     return propertyP(aa, ab, sa, sb, curry(f));
   }
 
@@ -580,7 +580,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, Property> f) {
+  public static <A, B> Property property(final Gen<A> aa, final Gen<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F2<A, B, Property> f) {
     return propertyP(aa, ab, sa, sb, compose2(P.p1(), curry(f)));
   }
 
@@ -594,7 +594,7 @@ public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B>
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B> ab, final F2<A, B, P1<Property>> f) {
+  public static <A, B> Property propertyP(final Gen<A> aa, final Gen<B> ab, final F2<A, B, P1<Property>> f) {
     return propertyP(aa, ab, curry(f));
   }
 
@@ -608,7 +608,7 @@ public static <A, B> Property propertyP(final Arbitrary<A> aa, final Arbitrary<B
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B> ab, final F2<A, B, Property> f) {
+  public static <A, B> Property property(final Gen<A> aa, final Gen<B> ab, final F2<A, B, Property> f) {
     return propertyP(aa, ab, compose2(P.p1(), curry(f)));
   }
 
@@ -626,9 +626,9 @@ public static <A, B> Property property(final Arbitrary<A> aa, final Arbitrary<B>
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C> Property property(final Arbitrary<A> aa,
-                                            final Arbitrary<B> ab,
-                                            final Arbitrary<C> ac,
+  public static <A, B, C> Property property(final Gen<A> aa,
+                                            final Gen<B> ab,
+                                            final Gen<C> ac,
                                             final Shrink<A> sa,
                                             final Shrink<B> sb,
                                             final Shrink<C> sc,
@@ -649,9 +649,9 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C> Property property(final Arbitrary<A> aa,
-                                            final Arbitrary<B> ab,
-                                            final Arbitrary<C> ac,
+  public static <A, B, C> Property property(final Gen<A> aa,
+                                            final Gen<B> ab,
+                                            final Gen<C> ac,
                                             final F<A, F<B, F<C, Property>>> f) {
     return property(aa, ab, a -> b -> property(ac, c -> f.f(a).f(b).f(c)));
   }
@@ -670,9 +670,9 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C> Property property(final Arbitrary<A> aa,
-                                            final Arbitrary<B> ab,
-                                            final Arbitrary<C> ac,
+  public static <A, B, C> Property property(final Gen<A> aa,
+                                            final Gen<B> ab,
+                                            final Gen<C> ac,
                                             final Shrink<A> sa,
                                             final Shrink<B> sb,
                                             final Shrink<C> sc,
@@ -691,9 +691,9 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C> Property property(final Arbitrary<A> aa,
-                                            final Arbitrary<B> ab,
-                                            final Arbitrary<C> ac,
+  public static <A, B, C> Property property(final Gen<A> aa,
+                                            final Gen<B> ab,
+                                            final Gen<C> ac,
                                             final F3<A, B, C, Property> f) {
     return property(aa, ab, ac, curry(f));
   }
@@ -714,10 +714,10 @@ public static <A, B, C> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D> Property property(final Arbitrary<A> aa,
-                                               final Arbitrary<B> ab,
-                                               final Arbitrary<C> ac,
-                                               final Arbitrary<D> ad,
+  public static <A, B, C, D> Property property(final Gen<A> aa,
+                                               final Gen<B> ab,
+                                               final Gen<C> ac,
+                                               final Gen<D> ad,
                                                final Shrink<A> sa,
                                                final Shrink<B> sb,
                                                final Shrink<C> sc,
@@ -740,10 +740,10 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D> Property property(final Arbitrary<A> aa,
-                                               final Arbitrary<B> ab,
-                                               final Arbitrary<C> ac,
-                                               final Arbitrary<D> ad,
+  public static <A, B, C, D> Property property(final Gen<A> aa,
+                                               final Gen<B> ab,
+                                               final Gen<C> ac,
+                                               final Gen<D> ad,
                                                final F<A, F<B, F<C, F<D, Property>>>> f) {
     return property(aa, ab, ac, a -> b -> c -> property(ad, d -> f.f(a).f(b).f(c).f(d)));
   }
@@ -764,10 +764,10 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D> Property property(final Arbitrary<A> aa,
-                                               final Arbitrary<B> ab,
-                                               final Arbitrary<C> ac,
-                                               final Arbitrary<D> ad,
+  public static <A, B, C, D> Property property(final Gen<A> aa,
+                                               final Gen<B> ab,
+                                               final Gen<C> ac,
+                                               final Gen<D> ad,
                                                final Shrink<A> sa,
                                                final Shrink<B> sb,
                                                final Shrink<C> sc,
@@ -788,10 +788,10 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D> Property property(final Arbitrary<A> aa,
-                                               final Arbitrary<B> ab,
-                                               final Arbitrary<C> ac,
-                                               final Arbitrary<D> ad,
+  public static <A, B, C, D> Property property(final Gen<A> aa,
+                                               final Gen<B> ab,
+                                               final Gen<C> ac,
+                                               final Gen<D> ad,
                                                final F4<A, B, C, D, Property> f) {
     return property(aa, ab, ac, ad, curry(f));
   }
@@ -814,11 +814,11 @@ public static <A, B, C, D> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
-                                                  final Arbitrary<B> ab,
-                                                  final Arbitrary<C> ac,
-                                                  final Arbitrary<D> ad,
-                                                  final Arbitrary<E> ae,
+  public static <A, B, C, D, E> Property property(final Gen<A> aa,
+                                                  final Gen<B> ab,
+                                                  final Gen<C> ac,
+                                                  final Gen<D> ad,
+                                                  final Gen<E> ae,
                                                   final Shrink<A> sa,
                                                   final Shrink<B> sb,
                                                   final Shrink<C> sc,
@@ -843,11 +843,11 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
-                                                  final Arbitrary<B> ab,
-                                                  final Arbitrary<C> ac,
-                                                  final Arbitrary<D> ad,
-                                                  final Arbitrary<E> ae,
+  public static <A, B, C, D, E> Property property(final Gen<A> aa,
+                                                  final Gen<B> ab,
+                                                  final Gen<C> ac,
+                                                  final Gen<D> ad,
+                                                  final Gen<E> ae,
                                                   final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
     return property(aa, ab, ac, ad, a -> b -> c -> d -> property(ae, e -> f.f(a).f(b).f(c).f(d).f(e)));
   }
@@ -870,11 +870,11 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
-                                                  final Arbitrary<B> ab,
-                                                  final Arbitrary<C> ac,
-                                                  final Arbitrary<D> ad,
-                                                  final Arbitrary<E> ae,
+  public static <A, B, C, D, E> Property property(final Gen<A> aa,
+                                                  final Gen<B> ab,
+                                                  final Gen<C> ac,
+                                                  final Gen<D> ad,
+                                                  final Gen<E> ae,
                                                   final Shrink<A> sa,
                                                   final Shrink<B> sb,
                                                   final Shrink<C> sc,
@@ -897,11 +897,11 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
-                                                  final Arbitrary<B> ab,
-                                                  final Arbitrary<C> ac,
-                                                  final Arbitrary<D> ad,
-                                                  final Arbitrary<E> ae,
+  public static <A, B, C, D, E> Property property(final Gen<A> aa,
+                                                  final Gen<B> ab,
+                                                  final Gen<C> ac,
+                                                  final Gen<D> ad,
+                                                  final Gen<E> ae,
                                                   final F5<A, B, C, D, E, Property> f) {
     return property(aa, ab, ac, ad, ae, curry(f));
   }
@@ -926,12 +926,12 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
-                                                      final Arbitrary<B> ab,
-                                                      final Arbitrary<C> ac,
-                                                      final Arbitrary<D> ad,
-                                                      final Arbitrary<E> ae,
-                                                      final Arbitrary<F$> af,
+  public static <A, B, C, D, E, F$> Property property(final Gen<A> aa,
+                                                      final Gen<B> ab,
+                                                      final Gen<C> ac,
+                                                      final Gen<D> ad,
+                                                      final Gen<E> ae,
+                                                      final Gen<F$> af,
                                                       final Shrink<A> sa,
                                                       final Shrink<B> sb,
                                                       final Shrink<C> sc,
@@ -958,12 +958,12 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
-                                                      final Arbitrary<B> ab,
-                                                      final Arbitrary<C> ac,
-                                                      final Arbitrary<D> ad,
-                                                      final Arbitrary<E> ae,
-                                                      final Arbitrary<F$> af,
+  public static <A, B, C, D, E, F$> Property property(final Gen<A> aa,
+                                                      final Gen<B> ab,
+                                                      final Gen<C> ac,
+                                                      final Gen<D> ad,
+                                                      final Gen<E> ae,
+                                                      final Gen<F$> af,
                                                       final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
     return property(aa, ab, ac, ad, ae, a -> b -> c -> d -> e -> property(af, f$ -> f.f(a).f(b).f(c).f(d).f(e).f(f$)));
   }
@@ -988,12 +988,12 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
-                                                      final Arbitrary<B> ab,
-                                                      final Arbitrary<C> ac,
-                                                      final Arbitrary<D> ad,
-                                                      final Arbitrary<E> ae,
-                                                      final Arbitrary<F$> af,
+  public static <A, B, C, D, E, F$> Property property(final Gen<A> aa,
+                                                      final Gen<B> ab,
+                                                      final Gen<C> ac,
+                                                      final Gen<D> ad,
+                                                      final Gen<E> ae,
+                                                      final Gen<F$> af,
                                                       final Shrink<A> sa,
                                                       final Shrink<B> sb,
                                                       final Shrink<C> sc,
@@ -1018,12 +1018,12 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$> Property property(final Arbitrary<A> aa,
-                                                      final Arbitrary<B> ab,
-                                                      final Arbitrary<C> ac,
-                                                      final Arbitrary<D> ad,
-                                                      final Arbitrary<E> ae,
-                                                      final Arbitrary<F$> af,
+  public static <A, B, C, D, E, F$> Property property(final Gen<A> aa,
+                                                      final Gen<B> ab,
+                                                      final Gen<C> ac,
+                                                      final Gen<D> ad,
+                                                      final Gen<E> ae,
+                                                      final Gen<F$> af,
                                                       final F6<A, B, C, D, E, F$, Property> f) {
     return property(aa, ab, ac, ad, ae, af, curry(f));
   }
@@ -1050,13 +1050,13 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
-                                                         final Arbitrary<B> ab,
-                                                         final Arbitrary<C> ac,
-                                                         final Arbitrary<D> ad,
-                                                         final Arbitrary<E> ae,
-                                                         final Arbitrary<F$> af,
-                                                         final Arbitrary<G> ag,
+  public static <A, B, C, D, E, F$, G> Property property(final Gen<A> aa,
+                                                         final Gen<B> ab,
+                                                         final Gen<C> ac,
+                                                         final Gen<D> ad,
+                                                         final Gen<E> ae,
+                                                         final Gen<F$> af,
+                                                         final Gen<G> ag,
                                                          final Shrink<A> sa,
                                                          final Shrink<B> sb,
                                                          final Shrink<C> sc,
@@ -1085,13 +1085,13 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
-                                                         final Arbitrary<B> ab,
-                                                         final Arbitrary<C> ac,
-                                                         final Arbitrary<D> ad,
-                                                         final Arbitrary<E> ae,
-                                                         final Arbitrary<F$> af,
-                                                         final Arbitrary<G> ag,
+  public static <A, B, C, D, E, F$, G> Property property(final Gen<A> aa,
+                                                         final Gen<B> ab,
+                                                         final Gen<C> ac,
+                                                         final Gen<D> ad,
+                                                         final Gen<E> ae,
+                                                         final Gen<F$> af,
+                                                         final Gen<G> ag,
                                                          final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
     return property(aa, ab, ac, ad, ae, af, a -> b -> c -> d -> e -> f$ -> property(ag, g -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g)));
   }
@@ -1118,13 +1118,13 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
-                                                         final Arbitrary<B> ab,
-                                                         final Arbitrary<C> ac,
-                                                         final Arbitrary<D> ad,
-                                                         final Arbitrary<E> ae,
-                                                         final Arbitrary<F$> af,
-                                                         final Arbitrary<G> ag,
+  public static <A, B, C, D, E, F$, G> Property property(final Gen<A> aa,
+                                                         final Gen<B> ab,
+                                                         final Gen<C> ac,
+                                                         final Gen<D> ad,
+                                                         final Gen<E> ae,
+                                                         final Gen<F$> af,
+                                                         final Gen<G> ag,
                                                          final Shrink<A> sa,
                                                          final Shrink<B> sb,
                                                          final Shrink<C> sc,
@@ -1151,13 +1151,13 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G> Property property(final Arbitrary<A> aa,
-                                                         final Arbitrary<B> ab,
-                                                         final Arbitrary<C> ac,
-                                                         final Arbitrary<D> ad,
-                                                         final Arbitrary<E> ae,
-                                                         final Arbitrary<F$> af,
-                                                         final Arbitrary<G> ag,
+  public static <A, B, C, D, E, F$, G> Property property(final Gen<A> aa,
+                                                         final Gen<B> ab,
+                                                         final Gen<C> ac,
+                                                         final Gen<D> ad,
+                                                         final Gen<E> ae,
+                                                         final Gen<F$> af,
+                                                         final Gen<G> ag,
                                                          final F7<A, B, C, D, E, F$, G, Property> f) {
     return property(aa, ab, ac, ad, ae, af, ag, curry(f));
   }
@@ -1186,14 +1186,14 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
-                                                            final Arbitrary<B> ab,
-                                                            final Arbitrary<C> ac,
-                                                            final Arbitrary<D> ad,
-                                                            final Arbitrary<E> ae,
-                                                            final Arbitrary<F$> af,
-                                                            final Arbitrary<G> ag,
-                                                            final Arbitrary<H> ah,
+  public static <A, B, C, D, E, F$, G, H> Property property(final Gen<A> aa,
+                                                            final Gen<B> ab,
+                                                            final Gen<C> ac,
+                                                            final Gen<D> ad,
+                                                            final Gen<E> ae,
+                                                            final Gen<F$> af,
+                                                            final Gen<G> ag,
+                                                            final Gen<H> ah,
                                                             final Shrink<A> sa,
                                                             final Shrink<B> sb,
                                                             final Shrink<C> sc,
@@ -1224,14 +1224,14 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
-                                                            final Arbitrary<B> ab,
-                                                            final Arbitrary<C> ac,
-                                                            final Arbitrary<D> ad,
-                                                            final Arbitrary<E> ae,
-                                                            final Arbitrary<F$> af,
-                                                            final Arbitrary<G> ag,
-                                                            final Arbitrary<H> ah,
+  public static <A, B, C, D, E, F$, G, H> Property property(final Gen<A> aa,
+                                                            final Gen<B> ab,
+                                                            final Gen<C> ac,
+                                                            final Gen<D> ad,
+                                                            final Gen<E> ae,
+                                                            final Gen<F$> af,
+                                                            final Gen<G> ag,
+                                                            final Gen<H> ah,
                                                             final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
     return property(aa, ab, ac, ad, ae, af, ag, a -> b -> c -> d -> e -> f$ -> g -> property(ah, h -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h)));
   }
@@ -1260,14 +1260,14 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
-                                                            final Arbitrary<B> ab,
-                                                            final Arbitrary<C> ac,
-                                                            final Arbitrary<D> ad,
-                                                            final Arbitrary<E> ae,
-                                                            final Arbitrary<F$> af,
-                                                            final Arbitrary<G> ag,
-                                                            final Arbitrary<H> ah,
+  public static <A, B, C, D, E, F$, G, H> Property property(final Gen<A> aa,
+                                                            final Gen<B> ab,
+                                                            final Gen<C> ac,
+                                                            final Gen<D> ad,
+                                                            final Gen<E> ae,
+                                                            final Gen<F$> af,
+                                                            final Gen<G> ag,
+                                                            final Gen<H> ah,
                                                             final Shrink<A> sa,
                                                             final Shrink<B> sb,
                                                             final Shrink<C> sc,
@@ -1296,14 +1296,14 @@ public static <A, B, C, D, E> Property property(final Arbitrary<A> aa,
    * @return A property where its result is derived from universal quantification across the
    *         application of its arguments.
    */
-  public static <A, B, C, D, E, F$, G, H> Property property(final Arbitrary<A> aa,
-                                                            final Arbitrary<B> ab,
-                                                            final Arbitrary<C> ac,
-                                                            final Arbitrary<D> ad,
-                                                            final Arbitrary<E> ae,
-                                                            final Arbitrary<F$> af,
-                                                            final Arbitrary<G> ag,
-                                                            final Arbitrary<H> ah,
+  public static <A, B, C, D, E, F$, G, H> Property property(final Gen<A> aa,
+                                                            final Gen<B> ab,
+                                                            final Gen<C> ac,
+                                                            final Gen<D> ad,
+                                                            final Gen<E> ae,
+                                                            final Gen<F$> af,
+                                                            final Gen<G> ag,
+                                                            final Gen<H> ah,
                                                             final F8<A, B, C, D, E, F$, G, H, Property> f) {
     return property(aa, ab, ac, ad, ae, af, ag, ah, curry(f));
   }
diff --git a/quickcheck/src/test/java/fj/data/test/TestCheck.java b/quickcheck/src/test/java/fj/data/test/TestCheck.java
index 10c59a1c..6bfaeaf7 100644
--- a/quickcheck/src/test/java/fj/data/test/TestCheck.java
+++ b/quickcheck/src/test/java/fj/data/test/TestCheck.java
@@ -10,7 +10,6 @@
 import org.junit.*;
 
 import static fj.Function.compose;
-import static fj.test.Arbitrary.*;
 import static fj.test.Arbitrary.arbLong;
 import static fj.test.Coarbitrary.coarbInteger;
 import static fj.test.Coarbitrary.coarbLong;
@@ -26,7 +25,7 @@ public void testExceptionsThrownFromGeneratorsArePropagated() {
 			throw new RuntimeException("test failure");
 		});
 
-		Property p = property(arbitrary(failingGen), (Integer i) -> {
+		Property p = property(failingGen, (Integer i) -> {
 			return prop(i == 0);
 		});
 
diff --git a/quickcheck/src/test/java/fj/data/test/TestNull.java b/quickcheck/src/test/java/fj/data/test/TestNull.java
index 6f7795aa..0346407d 100644
--- a/quickcheck/src/test/java/fj/data/test/TestNull.java
+++ b/quickcheck/src/test/java/fj/data/test/TestNull.java
@@ -10,7 +10,6 @@
 import org.junit.Test;
 
 import static fj.Function.compose;
-import static fj.test.Arbitrary.*;
 import static fj.test.Arbitrary.arbLong;
 import static fj.test.Coarbitrary.coarbInteger;
 import static fj.test.Coarbitrary.coarbLong;
@@ -24,7 +23,7 @@ public class TestNull {
 
 	@Test
 	public void testShowNullParameters() {
-		Property p = property(arbitrary(Gen.<Integer>value(null)), (Integer i) -> {
+		Property p = property(Gen.<Integer>value(null), (Integer i) -> {
 				return prop(i != null);
 		});
 		CheckResult.summary.println(p.check());
diff --git a/quickcheck/src/test/java/fj/test/TestBool.java b/quickcheck/src/test/java/fj/test/TestBool.java
index 2f29f69a..a2b9cae7 100644
--- a/quickcheck/src/test/java/fj/test/TestBool.java
+++ b/quickcheck/src/test/java/fj/test/TestBool.java
@@ -4,7 +4,6 @@
 import org.junit.Test;
 
 import static fj.test.Arbitrary.arbBoolean;
-import static fj.test.Arbitrary.arbitrary;
 import static fj.test.Bool.bool;
 import static fj.test.Property.property;
 
@@ -12,8 +11,7 @@ public class TestBool {
 
     @Test
     public void testBool() {
-        final Arbitrary<Boolean> arbBooleanR = arbitrary(arbBoolean.gen);
-        final Property p = property(arbBooleanR, arbBooleanR, (m1, m2) -> bool(m1.equals(m2))
+        final Property p = property(arbBoolean, arbBoolean, (m1, m2) -> bool(m1.equals(m2))
                 .implies(m1 == m2));
         PropertyAssert.assertResult(p);
     }

From 7f46d9df703c4ba4b8b28b0bc4c35273bf134b4b Mon Sep 17 00:00:00 2001
From: Charles O'Farrell <charleso@charleso.org>
Date: Wed, 8 Jun 2016 06:31:15 +1000
Subject: [PATCH 081/336] Rename Coarbitrary to Cogen

---
 .../java/fj/demo/test/ListFunctorLaws.java    |    6 +-
 .../src/test/java/fj/data/ReaderTest.java     |   18 +-
 .../src/test/java/fj/data/TestRngState.java   |   14 +-
 .../src/test/java/fj/data/WriterTest.java     |   12 +-
 .../src/main/java/fj/test/Arbitrary.java      |  142 +-
 .../src/main/java/fj/test/Coarbitrary.java    | 1184 -----------------
 quickcheck/src/main/java/fj/test/Cogen.java   | 1184 +++++++++++++++++
 .../src/test/java/fj/data/test/TestCheck.java |    2 -
 .../src/test/java/fj/data/test/TestNull.java  |    2 -
 9 files changed, 1280 insertions(+), 1284 deletions(-)
 delete mode 100644 quickcheck/src/main/java/fj/test/Coarbitrary.java
 create mode 100644 quickcheck/src/main/java/fj/test/Cogen.java

diff --git a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
index 6f17f827..46f7bdb0 100644
--- a/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
+++ b/demo/src/main/java/fj/demo/test/ListFunctorLaws.java
@@ -15,8 +15,8 @@
 import fj.function.Effect1;
 import fj.test.CheckResult;
 import static fj.test.CheckResult.summary;
-import static fj.test.Coarbitrary.coarbInteger;
-import static fj.test.Coarbitrary.coarbLong;
+import static fj.test.Cogen.cogenInteger;
+import static fj.test.Cogen.cogenLong;
 import fj.test.Property;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
@@ -42,7 +42,7 @@ For any list, mapping the identity function (\x -> x) produces the same list.
 public final class ListFunctorLaws {
   final Property identity = property(arbList(arbString), x -> prop(listEqual(stringEqual).eq(x, x.map(Function.identity()))));
 
-  final Property composition = property(arbF(coarbInteger, arbString), arbF(coarbLong, arbInteger), arbList(arbLong), (f, g, x) -> {
+  final Property composition = property(arbF(cogenInteger, arbString), arbF(cogenLong, arbInteger), arbList(arbLong), (f, g, x) -> {
       final List<String> s1 = x.map(compose(f, g));
       final List<String> s2 = x.map(g).map(f);
       return prop(listEqual(stringEqual).eq(s1, s2));
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 05c858b8..8494336e 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -8,7 +8,7 @@
 import static fj.F1Functions.bind;
 import static fj.F1Functions.map;
 import static fj.test.Arbitrary.*;
-import static fj.test.Coarbitrary.coarbInteger;
+import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.junit.Assert.assertTrue;
@@ -39,8 +39,8 @@ public void testFlatMap() {
     @Test
     public void testMapProp() {
         Property p = property(
-                arbF(coarbInteger, arbInteger),
-                arbF(coarbInteger, arbInteger),
+                arbF(cogenInteger, arbInteger),
+                arbF(cogenInteger, arbInteger),
                 arbInteger,
                 (f, g, i) -> {
                     int expected = map(f, g).f(i);
@@ -52,9 +52,9 @@ public void testMapProp() {
 
     @Test
     public void testFlatMapProp() {
-        Gen<F<Integer, Reader<Integer, Integer>>> a = arbF(coarbInteger, arbReader());
+        Gen<F<Integer, Reader<Integer, Integer>>> a = arbF(cogenInteger, arbReader());
         Property p = property(
-                arbF(coarbInteger, arbInteger),
+                arbF(cogenInteger, arbInteger),
                 a,
                 arbInteger,
                 (f, g, i) -> {
@@ -72,7 +72,7 @@ public void testLeftIdentity() {
         Property p = Property.property(
                 arbInteger,
                 arbInteger,
-                arbF(coarbInteger, arbReader()),
+                arbF(cogenInteger, arbReader()),
                 (i, j, f) -> {
                     int a = Reader.<Integer, Integer>constant(i).flatMap(f).f(j);
                     int b = f.f(i).f(j);
@@ -99,8 +99,8 @@ public void testAssociativity() {
         Property p = Property.property(
                 arbInteger,
                 arbReader(),
-                arbF(coarbInteger, arbReader()),
-                arbF(coarbInteger, arbReader()),
+                arbF(cogenInteger, arbReader()),
+                arbF(cogenInteger, arbReader()),
                 (i, r, f, g) -> {
                     boolean b2 = r.flatMap(f).flatMap(g).f(i) == r.flatMap(x -> f.f(x).flatMap(g)).f(i);
                     return prop(b2);
@@ -109,7 +109,7 @@ public void testAssociativity() {
     }
 
     public Gen<Reader<Integer, Integer>> arbReader() {
-        return Arbitrary.arbReader(coarbInteger, arbInteger);
+        return Arbitrary.arbReader(cogenInteger, arbInteger);
     }
 
 
diff --git a/props-core/src/test/java/fj/data/TestRngState.java b/props-core/src/test/java/fj/data/TestRngState.java
index ddc319b9..5f5f81bb 100644
--- a/props-core/src/test/java/fj/data/TestRngState.java
+++ b/props-core/src/test/java/fj/data/TestRngState.java
@@ -2,7 +2,7 @@
 
 import fj.*;
 import fj.test.Arbitrary;
-import fj.test.Coarbitrary;
+import fj.test.Cogen;
 import fj.test.Gen;
 import fj.test.Property;
 import org.junit.Assert;
@@ -12,7 +12,7 @@
 import static fj.data.Stream.unfold;
 import static fj.data.test.PropertyAssert.assertResult;
 import static fj.test.Arbitrary.*;
-import static fj.test.Coarbitrary.coarbInteger;
+import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static fj.test.Variant.variant;
@@ -80,19 +80,19 @@ public void testTraverse() {
     }
 
     public static Gen<State<LcgRng, Integer>> arbState() {
-        return Arbitrary.arbState(Arbitrary.arbLcgRng(), Coarbitrary.coarbLcgRng(), arbInteger);
+        return Arbitrary.arbState(Arbitrary.arbLcgRng(), Cogen.cogenLcgRng(), arbInteger);
     }
 
     public static Gen<F<LcgRng, P2<LcgRng, Integer>>> arbStateF() {
-        return arbF(Coarbitrary.coarbLcgRng(), arbP2(arbLcgRng(), arbInteger));
+        return arbF(Cogen.cogenLcgRng(), arbP2(arbLcgRng(), arbInteger));
     }
 
-    public static Coarbitrary<State<LcgRng, Integer>> coarbState() {
-        return Coarbitrary.coarbState(Arbitrary.arbLcgRng(), (LcgRng s, Integer j) -> (long) (j >= 0 ? 2 * j : -2 * j + 1));
+    public static Cogen<State<LcgRng, Integer>> cogenState() {
+        return Cogen.cogenState(Arbitrary.arbLcgRng(), (LcgRng s, Integer j) -> (long) (j >= 0 ? 2 * j : -2 * j + 1));
     }
 
     public static Gen<F<Integer, State<LcgRng, Integer>>> arbBindable() {
-        return arbF(coarbInteger, arbState());
+        return arbF(cogenInteger, arbState());
     }
 
     // Left identity: return i >>= f == f i
diff --git a/props-core/src/test/java/fj/data/WriterTest.java b/props-core/src/test/java/fj/data/WriterTest.java
index a2af9952..5f0ac122 100644
--- a/props-core/src/test/java/fj/data/WriterTest.java
+++ b/props-core/src/test/java/fj/data/WriterTest.java
@@ -11,7 +11,7 @@
 
 import static fj.data.test.PropertyAssert.assertResult;
 import static fj.test.Arbitrary.*;
-import static fj.test.Coarbitrary.coarbInteger;
+import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.junit.Assert.assertTrue;
@@ -46,7 +46,7 @@ public void testTellProp() {
 
     @Test
     public void testMap() {
-        Property p = property(arbInteger, arbF(coarbInteger, arbInteger), (i, f) -> {
+        Property p = property(arbInteger, arbF(cogenInteger, arbInteger), (i, f) -> {
             boolean b = eq.eq(defaultWriter.f(i).map(f), defaultWriter.f(f.f(i)));
             return prop(b);
         });
@@ -55,7 +55,7 @@ public void testMap() {
 
     @Test
     public void testFlatMap() {
-        Property p = property(arbInteger,arbF(coarbInteger, arbWriterStringInt()), (i, f) -> {
+        Property p = property(arbInteger,arbF(cogenInteger, arbWriterStringInt()), (i, f) -> {
             boolean b = eq.eq(Writer.<Integer>stringLogger().f(i).flatMap(f), f.f(i));
             return prop(b);
         });
@@ -76,7 +76,7 @@ public <A> Gen<Writer<String, A>> arbWriterString(Gen<A> arb) {
     public void testLeftIdentity() {
         Property p = Property.property(
                 arbInteger,
-                arbF(coarbInteger, arbWriterStringInt()),
+                arbF(cogenInteger, arbWriterStringInt()),
                 (i, f) -> {
                     return prop(eq.eq(defaultWriter.f(i).flatMap(f), f.f(i)));
                 });
@@ -98,8 +98,8 @@ public void testRightIdentity() {
     public void testAssociativity() {
         Property p = Property.property(
                 arbWriterStringInt(),
-                arbF(coarbInteger, arbWriterStringInt()),
-                arbF(coarbInteger, arbWriterStringInt()),
+                arbF(cogenInteger, arbWriterStringInt()),
+                arbF(cogenInteger, arbWriterStringInt()),
                 (w, f, g) -> {
                     boolean t = eq.eq(w.flatMap(f).flatMap(g), w.flatMap(x -> f.f(x).flatMap(g)));
                     return prop(t);
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 0b82108f..d8f88bed 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -83,26 +83,26 @@ public final class Arbitrary {
   /**
    * An arbitrary for functions.
    *
-   * @param c The coarbitrary for the function domain.
+   * @param c The cogen for the function domain.
    * @param a The arbitrary for the function codomain.
    * @return An arbitrary for functions.
    */
-  public static <A, B> Gen<F<A, B>> arbF(final Coarbitrary<A> c, final Gen<B> a) {
+  public static <A, B> Gen<F<A, B>> arbF(final Cogen<A> c, final Gen<B> a) {
     return promote(new F<A, Gen<B>>() {
       public Gen<B> f(final A x) {
-        return c.coarbitrary(x, a);
+        return c.cogen(x, a);
       }
     });
   }
 
-    public static <A, B> Gen<Reader<A, B>> arbReader(Coarbitrary<A> aa, Gen<B> ab) {
+    public static <A, B> Gen<Reader<A, B>> arbReader(Cogen<A> aa, Gen<B> ab) {
         return arbF(aa, ab).map(Reader::unit);
     }
 
     /**
      * An arbitrary for state.
      */
-    public static <S, A> Gen<State<S, A>> arbState(Gen<S> as, Coarbitrary<S> cs, Gen<A> aa) {
+    public static <S, A> Gen<State<S, A>> arbState(Gen<S> as, Cogen<S> cs, Gen<A> aa) {
         return arbF(cs, arbP2(as, aa)).map(State::unit);
     }
 
@@ -126,12 +126,12 @@ public static <A, B> Gen<F<A, B>> arbFInvariant(final Gen<B> a) {
   /**
    * An arbitrary for function-2.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-2.
    */
-  public static <A, B, C> Gen<F2<A, B, C>> arbF2(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
+  public static <A, B, C> Gen<F2<A, B, C>> arbF2(final Cogen<A> ca, final Cogen<B> cb,
                                                  final Gen<C> a) {
     return arbF(ca, arbF(cb, a)).map(Function.uncurryF2());
   }
@@ -149,14 +149,14 @@ public static <A, B, C> Gen<F2<A, B, C>> arbF2Invariant(final Gen<C> a) {
   /**
    * An arbitrary for function-3.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-3.
    */
-  public static <A, B, C, D> Gen<F3<A, B, C, D>> arbF3(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                       final Coarbitrary<C> cc, final Gen<D> a) {
+  public static <A, B, C, D> Gen<F3<A, B, C, D>> arbF3(final Cogen<A> ca, final Cogen<B> cb,
+                                                       final Cogen<C> cc, final Gen<D> a) {
     return arbF(ca, arbF(cb, arbF(cc, a))).map(Function.uncurryF3());
   }
 
@@ -176,15 +176,15 @@ public static <A, B, C, D> Gen<F3<A, B, C, D>> arbF3Invariant(final Gen<D> a) {
   /**
    * An arbitrary for function-4.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
-   * @param cd A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
+   * @param cd A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-4.
    */
-  public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                             final Coarbitrary<C> cc, final Coarbitrary<D> cd,
+  public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4(final Cogen<A> ca, final Cogen<B> cb,
+                                                             final Cogen<C> cc, final Cogen<D> cd,
                                                              final Gen<E> a) {
     return arbF(ca, arbF(cb, arbF(cc, arbF(cd, a)))).map(Function.uncurryF4());
   }
@@ -206,19 +206,19 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
   /**
    * An arbitrary for function-5.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
-   * @param cd A coarbitrary for the part of the domain of the function.
-   * @param ce A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
+   * @param cd A cogen for the part of the domain of the function.
+   * @param ce A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-5.
    */
-  public static <A, B, C, D, E, F$> Gen<F5<A, B, C, D, E, F$>> arbF5(final Coarbitrary<A> ca,
-                                                                     final Coarbitrary<B> cb,
-                                                                     final Coarbitrary<C> cc,
-                                                                     final Coarbitrary<D> cd,
-                                                                     final Coarbitrary<E> ce,
+  public static <A, B, C, D, E, F$> Gen<F5<A, B, C, D, E, F$>> arbF5(final Cogen<A> ca,
+                                                                     final Cogen<B> cb,
+                                                                     final Cogen<C> cc,
+                                                                     final Cogen<D> cd,
+                                                                     final Cogen<E> ce,
                                                                      final Gen<F$> a) {
     return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, a))))).map(Function.uncurryF5());
   }
@@ -241,21 +241,21 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
   /**
    * An arbitrary for function-6.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
-   * @param cd A coarbitrary for the part of the domain of the function.
-   * @param ce A coarbitrary for the part of the domain of the function.
-   * @param cf A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
+   * @param cd A cogen for the part of the domain of the function.
+   * @param ce A cogen for the part of the domain of the function.
+   * @param cf A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-6.
    */
-  public static <A, B, C, D, E, F$, G> Gen<F6<A, B, C, D, E, F$, G>> arbF6(final Coarbitrary<A> ca,
-                                                                           final Coarbitrary<B> cb,
-                                                                           final Coarbitrary<C> cc,
-                                                                           final Coarbitrary<D> cd,
-                                                                           final Coarbitrary<E> ce,
-                                                                           final Coarbitrary<F$> cf,
+  public static <A, B, C, D, E, F$, G> Gen<F6<A, B, C, D, E, F$, G>> arbF6(final Cogen<A> ca,
+                                                                           final Cogen<B> cb,
+                                                                           final Cogen<C> cc,
+                                                                           final Cogen<D> cd,
+                                                                           final Cogen<E> ce,
+                                                                           final Cogen<F$> cf,
                                                                            final Gen<G> a) {
     return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, a)))))).map(
         Function.uncurryF6());
@@ -280,23 +280,23 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
   /**
    * An arbitrary for function-7.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
-   * @param cd A coarbitrary for the part of the domain of the function.
-   * @param ce A coarbitrary for the part of the domain of the function.
-   * @param cf A coarbitrary for the part of the domain of the function.
-   * @param cg A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
+   * @param cd A cogen for the part of the domain of the function.
+   * @param ce A cogen for the part of the domain of the function.
+   * @param cf A cogen for the part of the domain of the function.
+   * @param cg A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-7.
    */
-  public static <A, B, C, D, E, F$, G, H> Gen<F7<A, B, C, D, E, F$, G, H>> arbF7(final Coarbitrary<A> ca,
-                                                                                 final Coarbitrary<B> cb,
-                                                                                 final Coarbitrary<C> cc,
-                                                                                 final Coarbitrary<D> cd,
-                                                                                 final Coarbitrary<E> ce,
-                                                                                 final Coarbitrary<F$> cf,
-                                                                                 final Coarbitrary<G> cg,
+  public static <A, B, C, D, E, F$, G, H> Gen<F7<A, B, C, D, E, F$, G, H>> arbF7(final Cogen<A> ca,
+                                                                                 final Cogen<B> cb,
+                                                                                 final Cogen<C> cc,
+                                                                                 final Cogen<D> cd,
+                                                                                 final Cogen<E> ce,
+                                                                                 final Cogen<F$> cf,
+                                                                                 final Cogen<G> cg,
                                                                                  final Gen<H> a) {
     return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, a))))))).map(
         Function.uncurryF7());
@@ -322,25 +322,25 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
   /**
    * An arbitrary for function-8.
    *
-   * @param ca A coarbitrary for the part of the domain of the function.
-   * @param cb A coarbitrary for the part of the domain of the function.
-   * @param cc A coarbitrary for the part of the domain of the function.
-   * @param cd A coarbitrary for the part of the domain of the function.
-   * @param ce A coarbitrary for the part of the domain of the function.
-   * @param cf A coarbitrary for the part of the domain of the function.
-   * @param cg A coarbitrary for the part of the domain of the function.
-   * @param ch A coarbitrary for the part of the domain of the function.
+   * @param ca A cogen for the part of the domain of the function.
+   * @param cb A cogen for the part of the domain of the function.
+   * @param cc A cogen for the part of the domain of the function.
+   * @param cd A cogen for the part of the domain of the function.
+   * @param ce A cogen for the part of the domain of the function.
+   * @param cf A cogen for the part of the domain of the function.
+   * @param cg A cogen for the part of the domain of the function.
+   * @param ch A cogen for the part of the domain of the function.
    * @param a  An arbitrary for the codomain of the function.
    * @return An arbitrary for function-8.
    */
-  public static <A, B, C, D, E, F$, G, H, I> Gen<F8<A, B, C, D, E, F$, G, H, I>> arbF8(final Coarbitrary<A> ca,
-                                                                                       final Coarbitrary<B> cb,
-                                                                                       final Coarbitrary<C> cc,
-                                                                                       final Coarbitrary<D> cd,
-                                                                                       final Coarbitrary<E> ce,
-                                                                                       final Coarbitrary<F$> cf,
-                                                                                       final Coarbitrary<G> cg,
-                                                                                       final Coarbitrary<H> ch,
+  public static <A, B, C, D, E, F$, G, H, I> Gen<F8<A, B, C, D, E, F$, G, H, I>> arbF8(final Cogen<A> ca,
+                                                                                       final Cogen<B> cb,
+                                                                                       final Cogen<C> cc,
+                                                                                       final Cogen<D> cd,
+                                                                                       final Cogen<E> ce,
+                                                                                       final Cogen<F$> cf,
+                                                                                       final Cogen<G> cg,
+                                                                                       final Cogen<H> ch,
                                                                                        final Gen<I> a) {
     return arbF(ca, arbF(cb, arbF(cc, arbF(cd, arbF(ce, arbF(cf, arbF(cg, arbF(ch, a)))))))).map(
         Function.uncurryF8());
diff --git a/quickcheck/src/main/java/fj/test/Coarbitrary.java b/quickcheck/src/main/java/fj/test/Coarbitrary.java
deleted file mode 100644
index 14c7acb4..00000000
--- a/quickcheck/src/main/java/fj/test/Coarbitrary.java
+++ /dev/null
@@ -1,1184 +0,0 @@
-package fj.test;
-
-import fj.*;
-
-import static fj.Function.curry;
-import static fj.P.p;
-
-import fj.data.*;
-
-import static fj.data.Array.array;
-import static fj.data.Array.iterableArray;
-import static fj.data.List.fromString;
-import static fj.data.List.nil;
-
-import static fj.test.Variant.variant;
-
-import static java.lang.Double.doubleToRawLongBits;
-import static java.lang.Float.floatToRawIntBits;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.sql.Time;
-import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.Calendar;
-import java.util.Date;
-import java.util.EnumMap;
-import java.util.EnumSet;
-import java.util.GregorianCalendar;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Hashtable;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.PriorityQueue;
-import java.util.Properties;
-import java.util.Stack;
-import java.util.TreeMap;
-import java.util.TreeSet;
-import java.util.Vector;
-import java.util.WeakHashMap;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.concurrent.CopyOnWriteArraySet;
-import java.util.concurrent.DelayQueue;
-import java.util.concurrent.Delayed;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.PriorityBlockingQueue;
-import java.util.concurrent.SynchronousQueue;
-
-/**
- * Transforms a type and a generator to produce a new generator. This function is used to generate
- * {@link Arbitrary arbitrary} functions.
- *
- * @version %build.number%
- */
-public abstract class Coarbitrary<A> {
-  /**
-   * Transforms the given value and generator to a new generator with a high probability of being
-   * independent.
-   *
-   * @param a The value to produce the generator from.
-   * @param g The generator to produce the new generator from.
-   * @return A new generator with a high probability of being independent.
-   */
-  public abstract <B> Gen<B> coarbitrary(A a, Gen<B> g);
-
-
-  /**
-   * A curried version of {@link #coarbitrary(Object, Gen)}.
-   *
-   * @param a The value to produce the generator from.
-   * @return A curried version of {@link #coarbitrary(Object, Gen)}.
-   */
-  public final <B> F<Gen<B>, Gen<B>> coarbitrary(final A a) {
-    return g -> coarbitrary(a, g);
-  }
-
-  /**
-   * Composes the given function with this coarbitrary to produce a new coarbitrary.
-   *
-   * @param f The function to compose.
-   * @return A new coarbitrary composed with the given function.
-   */
-  public final <B> Coarbitrary<B> compose(final F<B, A> f) {
-    return new Coarbitrary<B>() {
-      public <X> Gen<X> coarbitrary(final B b, final Gen<X> g) {
-        return Coarbitrary.this.coarbitrary(f.f(b), g);
-      }
-    };
-  }
-
-  /**
-   * Contra-maps this coarbitrary using the given function.
-   *
-   * @param f The function to co-map with.
-   * @return A contra-mapped coarbitrary.
-   */
-  public final <B> Coarbitrary<B> contramap(final F<B, A> f) {
-    return new Coarbitrary<B>() {
-      public <X> Gen<X> coarbitrary(final B b, final Gen<X> g) {
-        return Coarbitrary.this.coarbitrary(f.f(b), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function.
-   *
-   * @param a An arbitrary for the domain of the function.
-   * @param c A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function.
-   */
-  public static <A, B> Coarbitrary<F<A, B>> coarbF(final Gen<A> a, final Coarbitrary<B> c) {
-    return new Coarbitrary<F<A, B>>() {
-      public <X> Gen<X> coarbitrary(final F<A, B> f, final Gen<X> g) {
-        return a.bind(a1 -> c.coarbitrary(f.f(a1), g));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-2.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-2.
-   */
-  public static <A, B, C> Coarbitrary<F2<A, B, C>> coarbF2(final Gen<A> aa, final Gen<B> ab,
-                                                           final Coarbitrary<C> c) {
-    return new Coarbitrary<F2<A, B, C>>() {
-      public <X> Gen<X> coarbitrary(final F2<A, B, C> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, c)).coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-3.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-3.
-   */
-  public static <A, B, C, D> Coarbitrary<F3<A, B, C, D>> coarbF3(final Gen<A> aa, final Gen<B> ab,
-                                                                 final Gen<C> ac, final Coarbitrary<D> c) {
-    return new Coarbitrary<F3<A, B, C, D>>() {
-      public <X> Gen<X> coarbitrary(final F3<A, B, C, D> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, c))).coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-4.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param ad An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-4.
-   */
-  public static <A, B, C, D, E> Coarbitrary<F4<A, B, C, D, E>> coarbF4(final Gen<A> aa, final Gen<B> ab,
-                                                                       final Gen<C> ac, final Gen<D> ad,
-                                                                       final Coarbitrary<E> c) {
-    return new Coarbitrary<F4<A, B, C, D, E>>() {
-      public <X> Gen<X> coarbitrary(final F4<A, B, C, D, E> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, c)))).coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-5.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param ad An arbitrary for part of the domain of the function.
-   * @param ae An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-5.
-   */
-  public static <A, B, C, D, E, F$> Coarbitrary<F5<A, B, C, D, E, F$>> coarbF5(final Gen<A> aa,
-                                                                               final Gen<B> ab,
-                                                                               final Gen<C> ac,
-                                                                               final Gen<D> ad,
-                                                                               final Gen<E> ae,
-                                                                               final Coarbitrary<F$> c) {
-    return new Coarbitrary<F5<A, B, C, D, E, F$>>() {
-      public <X> Gen<X> coarbitrary(final F5<A, B, C, D, E, F$> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, c))))).coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-6.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param ad An arbitrary for part of the domain of the function.
-   * @param ae An arbitrary for part of the domain of the function.
-   * @param af An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-6.
-   */
-  public static <A, B, C, D, E, F$, G> Coarbitrary<F6<A, B, C, D, E, F$, G>> coarbF6(final Gen<A> aa,
-                                                                                     final Gen<B> ab,
-                                                                                     final Gen<C> ac,
-                                                                                     final Gen<D> ad,
-                                                                                     final Gen<E> ae,
-                                                                                     final Gen<F$> af,
-                                                                                     final Coarbitrary<G> c) {
-    return new Coarbitrary<F6<A, B, C, D, E, F$, G>>() {
-      public <X> Gen<X> coarbitrary(final F6<A, B, C, D, E, F$, G> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, c)))))).coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-7.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param ad An arbitrary for part of the domain of the function.
-   * @param ae An arbitrary for part of the domain of the function.
-   * @param af An arbitrary for part of the domain of the function.
-   * @param ag An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-7.
-   */
-  public static <A, B, C, D, E, F$, G, H> Coarbitrary<F7<A, B, C, D, E, F$, G, H>> coarbF7(final Gen<A> aa,
-                                                                                           final Gen<B> ab,
-                                                                                           final Gen<C> ac,
-                                                                                           final Gen<D> ad,
-                                                                                           final Gen<E> ae,
-                                                                                           final Gen<F$> af,
-                                                                                           final Gen<G> ag,
-                                                                                           final Coarbitrary<H> c) {
-    return new Coarbitrary<F7<A, B, C, D, E, F$, G, H>>() {
-      public <X> Gen<X> coarbitrary(final F7<A, B, C, D, E, F$, G, H> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, coarbF(ag, c)))))))
-            .coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for a function-8.
-   *
-   * @param aa An arbitrary for part of the domain of the function.
-   * @param ab An arbitrary for part of the domain of the function.
-   * @param ac An arbitrary for part of the domain of the function.
-   * @param ad An arbitrary for part of the domain of the function.
-   * @param ae An arbitrary for part of the domain of the function.
-   * @param af An arbitrary for part of the domain of the function.
-   * @param ag An arbitrary for part of the domain of the function.
-   * @param ah An arbitrary for part of the domain of the function.
-   * @param c  A coarbitrary for the codomain of the function.
-   * @return A coarbitrary for a function-8.
-   */
-  public static <A, B, C, D, E, F$, G, H, I> Coarbitrary<F8<A, B, C, D, E, F$, G, H, I>> coarbF8(final Gen<A> aa,
-                                                                                                 final Gen<B> ab,
-                                                                                                 final Gen<C> ac,
-                                                                                                 final Gen<D> ad,
-                                                                                                 final Gen<E> ae,
-                                                                                                 final Gen<F$> af,
-                                                                                                 final Gen<G> ag,
-                                                                                                 final Gen<H> ah,
-                                                                                                 final Coarbitrary<I> c) {
-    return new Coarbitrary<F8<A, B, C, D, E, F$, G, H, I>>() {
-      public <X> Gen<X> coarbitrary(final F8<A, B, C, D, E, F$, G, H, I> f, final Gen<X> g) {
-        return coarbF(aa, coarbF(ab, coarbF(ac, coarbF(ad, coarbF(ae, coarbF(af, coarbF(ag, coarbF(ah, c))))))))
-            .coarbitrary(curry(f), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for booleans.
-   */
-  public static final Coarbitrary<Boolean> coarbBoolean = new Coarbitrary<Boolean>() {
-    public <B> Gen<B> coarbitrary(final Boolean b, final Gen<B> g) {
-      return variant(b ? 0 : 1, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for integers.
-   */
-  public static final Coarbitrary<Integer> coarbInteger = new Coarbitrary<Integer>() {
-    public <B> Gen<B> coarbitrary(final Integer i, final Gen<B> g) {
-      return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for bytes.
-   */
-  public static final Coarbitrary<Byte> coarbByte = new Coarbitrary<Byte>() {
-    public <B> Gen<B> coarbitrary(final Byte b, final Gen<B> g) {
-      return variant(b >= 0 ? 2 * b : -2 * b + 1, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for shorts.
-   */
-  public static final Coarbitrary<Short> coarbShort = new Coarbitrary<Short>() {
-    public <B> Gen<B> coarbitrary(final Short s, final Gen<B> g) {
-      return variant(s >= 0 ? 2 * s : -2 * s + 1, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for longs.
-   */
-  public static final Coarbitrary<Long> coarbLong = new Coarbitrary<Long>() {
-    public <B> Gen<B> coarbitrary(final Long l, final Gen<B> g) {
-      return variant(l >= 0L ? 2L * l : -2L * l + 1L, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for characters.
-   */
-  public static final Coarbitrary<Character> coarbCharacter = new Coarbitrary<Character>() {
-    public <B> Gen<B> coarbitrary(final Character c, final Gen<B> g) {
-      return variant(c << 1, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for floats.
-   */
-  public static final Coarbitrary<Float> coarbFloat = new Coarbitrary<Float>() {
-    public <B> Gen<B> coarbitrary(final Float f, final Gen<B> g) {
-      return coarbInteger.coarbitrary(floatToRawIntBits(f), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for doubles.
-   */
-  public static final Coarbitrary<Double> coarbDouble = new Coarbitrary<Double>() {
-    public <B> Gen<B> coarbitrary(final Double d, final Gen<B> g) {
-      return coarbLong.coarbitrary(doubleToRawLongBits(d), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for the optional value.
-   *
-   * @param ca A coarbitrary for the type of the optional value.
-   * @return A coarbitrary for the optional value.
-   */
-  public static <A> Coarbitrary<Option<A>> coarbOption(final Coarbitrary<A> ca) {
-    return new Coarbitrary<Option<A>>() {
-      public <B> Gen<B> coarbitrary(final Option<A> o, final Gen<B> g) {
-        return o.isNone() ? variant(0, g) : variant(1, ca.coarbitrary(o.some(), g));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for the disjoint union.
-   *
-   * @param ca A coarbitrary for one side of the disjoint union.
-   * @param cb A coarbitrary for one side of the disjoint union.
-   * @return A coarbitrary for the disjoint union.
-   */
-  public static <A, B> Coarbitrary<Either<A, B>> coarbEither(final Coarbitrary<A> ca, final Coarbitrary<B> cb) {
-    return new Coarbitrary<Either<A, B>>() {
-      public <X> Gen<X> coarbitrary(final Either<A, B> e, final Gen<X> g) {
-        return e.isLeft() ?
-            variant(0, ca.coarbitrary(e.left().value(), g)) :
-            variant(1, cb.coarbitrary(e.right().value(), g));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for lists.
-   *
-   * @param ca A coarbitrary for the elements of the list.
-   * @return A coarbitrary for lists.
-   */
-  public static <A> Coarbitrary<List<A>> coarbList(final Coarbitrary<A> ca) {
-    return new Coarbitrary<List<A>>() {
-      public <B> Gen<B> coarbitrary(final List<A> as, final Gen<B> g) {
-        return as.isEmpty() ?
-            variant(0, g) :
-            variant(1, ca.coarbitrary(as.head(), coarbitrary(as.tail(), g)));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for strings.
-   */
-  public static final Coarbitrary<String> coarbString = new Coarbitrary<String>() {
-    public <B> Gen<B> coarbitrary(final String s, final Gen<B> g) {
-      return coarbList(coarbCharacter).coarbitrary(fromString(s), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for string buffers.
-   */
-  public static final Coarbitrary<StringBuffer> coarbStringBuffer = new Coarbitrary<StringBuffer>() {
-    public <B> Gen<B> coarbitrary(final StringBuffer s, final Gen<B> g) {
-      return coarbString.coarbitrary(s.toString(), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for string builders.
-   */
-  public static final Coarbitrary<StringBuilder> coarbStringBuilder = new Coarbitrary<StringBuilder>() {
-    public <B> Gen<B> coarbitrary(final StringBuilder s, final Gen<B> g) {
-      return coarbString.coarbitrary(s.toString(), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for streams.
-   *
-   * @param ca A coarbitrary for the elements of the stream.
-   * @return A coarbitrary for streams.
-   */
-  public static <A> Coarbitrary<Stream<A>> coarbStream(final Coarbitrary<A> ca) {
-    return new Coarbitrary<Stream<A>>() {
-      public <B> Gen<B> coarbitrary(final Stream<A> as, final Gen<B> g) {
-        return as.isEmpty() ?
-            variant(0, g) :
-            variant(1, ca.coarbitrary(as.head(), coarbitrary(as.tail()._1(), g)));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for the provided LcgRng
-   * @return A coarbitrary for the provided LcgRng.
-   */
-  public static Coarbitrary<LcgRng> coarbLcgRng() {
-    return new Coarbitrary<LcgRng>() {
-      @Override
-      public <B> Gen<B> coarbitrary(LcgRng rng, Gen<B> g) {
-        long i = rng.getSeed();
-        return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for state.
-   */
-  public static <S, A> Coarbitrary<State<S, A>> coarbState(Gen<S> as, F2<S, A, Long> f) {
-    return new Coarbitrary<State<S, A>>() {
-      @Override
-      public <B> Gen<B> coarbitrary(State<S, A> s1, Gen<B> g) {
-        return as.bind(r -> {
-          P2<S, A> p = s1.run(r);
-          return variant(f.f(p._1(), p._2()), g);
-        });
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for arrays.
-   *
-   * @param ca A coarbitrary for the elements of the array.
-   * @return A coarbitrary for arrays.
-   */
-  public static <A> Coarbitrary<Array<A>> coarbArray(final Coarbitrary<A> ca) {
-    return new Coarbitrary<Array<A>>() {
-      public <B> Gen<B> coarbitrary(final Array<A> as, final Gen<B> g) {
-        return coarbList(ca).coarbitrary(as.toList(), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for throwables.
-   *
-   * @param cs A coarbitrary for the throwable message.
-   * @return A coarbitrary for throwables.
-   */
-  public static Coarbitrary<Throwable> coarbThrowable(final Coarbitrary<String> cs) {
-    return cs.contramap(new F<Throwable, String>() {
-      public String f(final Throwable t) {
-        return t.getMessage();
-      }
-    });
-  }
-
-  /**
-   * A coarbitrary for throwables.
-   */
-  public static final Coarbitrary<Throwable> coarbThrowable =
-      coarbThrowable(coarbString);
-
-  // BEGIN java.util
-
-  /**
-   * A coarbitrary for array lists.
-   *
-   * @param ca A coarbitrary for the elements of the array list.
-   * @return A coarbitrary for array lists.
-   */
-  public static <A> Coarbitrary<ArrayList<A>> coarbArrayList(final Coarbitrary<A> ca) {
-    return new Coarbitrary<ArrayList<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final ArrayList<A> as, final Gen<B> g) {
-        return coarbArray(ca).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for bit sets.
-   */
-  public static final Coarbitrary<BitSet> coarbBitSet = new Coarbitrary<BitSet>() {
-    public <B> Gen<B> coarbitrary(final BitSet s, final Gen<B> g) {
-      List<Boolean> x = nil();
-
-      for (int i = 0; i < s.size(); i++) {
-        x = x.snoc(s.get(i));
-      }
-
-      return coarbList(coarbBoolean).coarbitrary(x, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for calendars.
-   */
-  public static final Coarbitrary<Calendar> coarbCalendar = new Coarbitrary<Calendar>() {
-    public <B> Gen<B> coarbitrary(final Calendar c, final Gen<B> g) {
-      return coarbLong.coarbitrary(c.getTime().getTime(), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for dates.
-   */
-  public static final Coarbitrary<Date> coarbDate = new Coarbitrary<Date>() {
-    public <B> Gen<B> coarbitrary(final Date d, final Gen<B> g) {
-      return coarbLong.coarbitrary(d.getTime(), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for enum maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for enum maps.
-   */
-  public static <K extends Enum<K>, V> Coarbitrary<EnumMap<K, V>> coarbEnumMap(final Coarbitrary<K> ck,
-                                                                               final Coarbitrary<V> cv) {
-    return new Coarbitrary<EnumMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final EnumMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for enum sets.
-   *
-   * @param c A coarbitrary for the elements of the enum set.
-   * @return A coarbitrary for enum sets.
-   */
-  public static <A extends Enum<A>> Coarbitrary<EnumSet<A>> coarbEnumSet(final Coarbitrary<A> c) {
-    return new Coarbitrary<EnumSet<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final EnumSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for gregorian calendars.
-   */
-  public static final Coarbitrary<GregorianCalendar> coarbGregorianCalendar = new Coarbitrary<GregorianCalendar>() {
-    public <B> Gen<B> coarbitrary(final GregorianCalendar c, final Gen<B> g) {
-      return coarbLong.coarbitrary(c.getTime().getTime(), g);
-    }
-  };
-
-  /**
-   * A coarbitrary for hash maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for hash maps.
-   */
-  public static <K, V> Coarbitrary<HashMap<K, V>> coarbHashMap(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
-    return new Coarbitrary<HashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final HashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for hash sets.
-   *
-   * @param c A coarbitrary for the elements of the hash set.
-   * @return A coarbitrary for hash sets.
-   */
-  public static <A> Coarbitrary<HashSet<A>> coarbHashSet(final Coarbitrary<A> c) {
-    return new Coarbitrary<HashSet<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final HashSet<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for hash tables.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for hash tables.
-   */
-  public static <K, V> Coarbitrary<Hashtable<K, V>> coarbHashtable(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
-    return new Coarbitrary<Hashtable<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final Hashtable<K, V> h, final Gen<B> g) {
-        List<P2<K, V>> x = nil();
-
-        for (final Map.Entry<K, V> entry : h.entrySet()) {
-          x = x.snoc(p(entry.getKey(), entry.getValue()));
-        }
-
-        return coarbList(coarbP2(ck, cv)).coarbitrary(x, g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for identity hash maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for identity hash maps.
-   */
-  public static <K, V> Coarbitrary<IdentityHashMap<K, V>> coarbIdentityHashMap(final Coarbitrary<K> ck,
-                                                                               final Coarbitrary<V> cv) {
-    return new Coarbitrary<IdentityHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final IdentityHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for linked hash maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for linked hash maps.
-   */
-  public static <K, V> Coarbitrary<LinkedHashMap<K, V>> coarbLinkedHashMap(final Coarbitrary<K> ck,
-                                                                           final Coarbitrary<V> cv) {
-    return new Coarbitrary<LinkedHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final LinkedHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for linked hash sets.
-   *
-   * @param c A coarbitrary for the elements of the linked hash set.
-   * @return A coarbitrary for linked hash sets.
-   */
-  public static <A> Coarbitrary<LinkedHashSet<A>> coarbLinkedHashSet(final Coarbitrary<A> c) {
-    return new Coarbitrary<LinkedHashSet<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final LinkedHashSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for linked lists.
-   *
-   * @param c A coarbitrary for the elements of the linked list.
-   * @return A coarbitrary for linked lists.
-   */
-  public static <A> Coarbitrary<LinkedList<A>> coarbLinkedList(final Coarbitrary<A> c) {
-    return new Coarbitrary<LinkedList<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final LinkedList<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for priority queues.
-   *
-   * @param c A coarbitrary for the elements of the priority queue.
-   * @return A coarbitrary for priority queues.
-   */
-  public static <A> Coarbitrary<PriorityQueue<A>> coarbPriorityQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<PriorityQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final PriorityQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for properties.
-   */
-  public static final Coarbitrary<Properties> coarbProperties = new Coarbitrary<Properties>() {
-    @SuppressWarnings("UseOfObsoleteCollectionType")
-    public <B> Gen<B> coarbitrary(final Properties p, final Gen<B> g) {
-      final Hashtable<String, String> t = new Hashtable<>();
-
-      for (final Object s : p.keySet()) {
-        t.put((String) s, p.getProperty((String) s));
-      }
-
-      return coarbHashtable(coarbString, coarbString).coarbitrary(t, g);
-    }
-  };
-
-  /**
-   * A coarbitrary for stacks.
-   *
-   * @param c A coarbitrary for the elements of the stack.
-   * @return A coarbitrary for stacks.
-   */
-  public static <A> Coarbitrary<Stack<A>> coarbStack(final Coarbitrary<A> c) {
-    return new Coarbitrary<Stack<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final Stack<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for tree maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for tree maps.
-   */
-  public static <K, V> Coarbitrary<TreeMap<K, V>> coarbTreeMap(final Coarbitrary<K> ck, final Coarbitrary<V> cv) {
-    return new Coarbitrary<TreeMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final TreeMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for tree sets.
-   *
-   * @param c A coarbitrary for the elements of the tree set.
-   * @return A coarbitrary for tree sets.
-   */
-  public static <A> Coarbitrary<TreeSet<A>> coarbTreeSet(final Coarbitrary<A> c) {
-    return new Coarbitrary<TreeSet<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final TreeSet<A> as, final Gen<B> g) {
-        return coarbHashSet(c).coarbitrary(new HashSet<>(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for vectors.
-   *
-   * @param c A coarbitrary for the elements of the vector.
-   * @return A coarbitrary for vectors.
-   */
-  public static <A> Coarbitrary<Vector<A>> coarbVector(final Coarbitrary<A> c) {
-    return new Coarbitrary<Vector<A>>() {
-      @SuppressWarnings({"unchecked", "UseOfObsoleteCollectionType"})
-      public <B> Gen<B> coarbitrary(final Vector<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for weak hash maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for weak hash maps.
-   */
-  public static <K, V> Coarbitrary<WeakHashMap<K, V>> coarbWeakHashMap(final Coarbitrary<K> ck,
-                                                                       final Coarbitrary<V> cv) {
-    return new Coarbitrary<WeakHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final WeakHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  // END java.util
-
-  // BEGIN java.util.concurrent
-
-  /**
-   * A coarbitrary for array blocking queues.
-   *
-   * @param c A coarbitrary for the elements of the array blocking queue.
-   * @return A coarbitrary for array blocking queues.
-   */
-  public static <A> Coarbitrary<ArrayBlockingQueue<A>> coarbArrayBlockingQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<ArrayBlockingQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final ArrayBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for concurrent hash maps.
-   *
-   * @param ck A coarbitrary for the map keys.
-   * @param cv A coarbitrary for the map values.
-   * @return A coarbitrary for concurrent hash maps.
-   */
-  public static <K, V> Coarbitrary<ConcurrentHashMap<K, V>> coarbConcurrentHashMap(final Coarbitrary<K> ck,
-                                                                                   final Coarbitrary<V> cv) {
-    return new Coarbitrary<ConcurrentHashMap<K, V>>() {
-      @SuppressWarnings("UseOfObsoleteCollectionType")
-      public <B> Gen<B> coarbitrary(final ConcurrentHashMap<K, V> m, final Gen<B> g) {
-        return coarbHashtable(ck, cv).coarbitrary(new Hashtable<>(m), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for concurrent linked queues.
-   *
-   * @param c A coarbitrary for the elements of the concurrent linked queue.
-   * @return A coarbitrary for concurrent linked queues.
-   */
-  public static <A> Coarbitrary<ConcurrentLinkedQueue<A>> coarbConcurrentLinkedQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<ConcurrentLinkedQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final ConcurrentLinkedQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for copy-on-write array lists.
-   *
-   * @param c A coarbitrary for the elements of the copy-on-write array list.
-   * @return A coarbitrary for copy-on-write array lists.
-   */
-  public static <A> Coarbitrary<CopyOnWriteArrayList<A>> coarbCopyOnWriteArrayList(final Coarbitrary<A> c) {
-    return new Coarbitrary<CopyOnWriteArrayList<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final CopyOnWriteArrayList<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for copy-on-write array sets.
-   *
-   * @param c A coarbitrary for the elements of the copy-on-write array set.
-   * @return A coarbitrary for copy-on-write array sets.
-   */
-  public static <A> Coarbitrary<CopyOnWriteArraySet<A>> coarbCopyOnWriteArraySet(final Coarbitrary<A> c) {
-    return new Coarbitrary<CopyOnWriteArraySet<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final CopyOnWriteArraySet<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for delay queues.
-   *
-   * @param c A coarbitrary for the elements of the delay queue.
-   * @return A coarbitrary for delay queues.
-   */
-  public static <A extends Delayed> Coarbitrary<DelayQueue<A>> coarbDelayQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<DelayQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final DelayQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for linked blocking queues.
-   *
-   * @param c A coarbitrary for the elements of the linked blocking queue.
-   * @return A coarbitrary for linked blocking queues.
-   */
-  public static <A> Coarbitrary<LinkedBlockingQueue<A>> coarbLinkedBlockingQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<LinkedBlockingQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final LinkedBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for priority blocking queues.
-   *
-   * @param c A coarbitrary for the elements of the priority blocking queue.
-   * @return A coarbitrary for priority blocking queues.
-   */
-  public static <A> Coarbitrary<PriorityBlockingQueue<A>> coarbPriorityBlockingQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<PriorityBlockingQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final PriorityBlockingQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for synchronous queues.
-   *
-   * @param c A coarbitrary for the elements of the synchronous queue.
-   * @return A coarbitrary for synchronous queues.
-   */
-  public static <A> Coarbitrary<SynchronousQueue<A>> coarbSynchronousQueue(final Coarbitrary<A> c) {
-    return new Coarbitrary<SynchronousQueue<A>>() {
-      @SuppressWarnings("unchecked")
-      public <B> Gen<B> coarbitrary(final SynchronousQueue<A> as, final Gen<B> g) {
-        return coarbArray(c).coarbitrary(iterableArray(as), g);
-      }
-    };
-  }
-
-  // END java.util.concurrent
-
-  // BEGIN java.sql
-
-  public static final Coarbitrary<java.sql.Date> coarbSQLDate = new Coarbitrary<java.sql.Date>() {
-    public <B> Gen<B> coarbitrary(final java.sql.Date d, final Gen<B> g) {
-      return coarbLong.coarbitrary(d.getTime(), g);
-    }
-  };
-
-  public static final Coarbitrary<Timestamp> coarbTimestamp = new Coarbitrary<Timestamp>() {
-    public <B> Gen<B> coarbitrary(final Timestamp t, final Gen<B> g) {
-      return coarbLong.coarbitrary(t.getTime(), g);
-    }
-  };
-
-  public static final Coarbitrary<Time> coarbTime = new Coarbitrary<Time>() {
-    public <B> Gen<B> coarbitrary(final Time t, final Gen<B> g) {
-      return coarbLong.coarbitrary(t.getTime(), g);
-    }
-  };
-
-  // END java.sql
-
-  // BEGIN java.math
-
-  public static final Coarbitrary<BigInteger> coarbBigInteger = new Coarbitrary<BigInteger>() {
-    public <B> Gen<B> coarbitrary(final BigInteger i, final Gen<B> g) {
-      return variant((i.compareTo(BigInteger.ZERO) >= 0 ?
-          i.multiply(BigInteger.valueOf(2L)) :
-          i.multiply(BigInteger.valueOf(-2L).add(BigInteger.ONE))).longValue(), g);
-    }
-  };
-
-  public static final Coarbitrary<BigDecimal> coarbBigDecimal = new Coarbitrary<BigDecimal>() {
-    public <B> Gen<B> coarbitrary(final BigDecimal d, final Gen<B> g) {
-      return variant((d.compareTo(BigDecimal.ZERO) >= 0 ?
-          d.multiply(BigDecimal.valueOf(2L)) :
-          d.multiply(BigDecimal.valueOf(-2L).add(BigDecimal.ONE))).longValue(), g);
-    }
-  };
-
-  // END java.math
-
-  /**
-   * A coarbitrary for product-1 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-1 is defined.
-   * @return A coarbitrary for product-1 values.
-   */
-  public static <A> Coarbitrary<P1<A>> coarbP1(final Coarbitrary<A> ca) {
-    return new Coarbitrary<P1<A>>() {
-      public <B> Gen<B> coarbitrary(final P1<A> p, final Gen<B> g) {
-        return ca.coarbitrary(p._1(), g);
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-2 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-2 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-2 is defined.
-   * @return A coarbitrary for product-2 values.
-   */
-  public static <A, B> Coarbitrary<P2<A, B>> coarbP2(final Coarbitrary<A> ca, final Coarbitrary<B> cb) {
-    return new Coarbitrary<P2<A, B>>() {
-      public <X> Gen<X> coarbitrary(final P2<A, B> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(), g));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-3 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-3 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-3 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-3 is defined.
-   * @return A coarbitrary for product-3 values.
-   */
-  public static <A, B, C> Coarbitrary<P3<A, B, C>> coarbP3(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                           final Coarbitrary<C> cc) {
-    return new Coarbitrary<P3<A, B, C>>() {
-      public <X> Gen<X> coarbitrary(final P3<A, B, C> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(), cc.coarbitrary(p._3(), g)));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-4 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-4 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-4 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-4 is defined.
-   * @param cd A coarbitrary for one of the types over which the product-4 is defined.
-   * @return A coarbitrary for product-4 values.
-   */
-  public static <A, B, C, D> Coarbitrary<P4<A, B, C, D>> coarbP4(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                                 final Coarbitrary<C> cc, final Coarbitrary<D> cd) {
-    return new Coarbitrary<P4<A, B, C, D>>() {
-      public <X> Gen<X> coarbitrary(final P4<A, B, C, D> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(), cc.coarbitrary(p._3(), cd.coarbitrary(p._4(), g))));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-5 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-5 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-5 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-5 is defined.
-   * @param cd A coarbitrary for one of the types over which the product-5 is defined.
-   * @param ce A coarbitrary for one of the types over which the product-5 is defined.
-   * @return A coarbitrary for product-5 values.
-   */
-  public static <A, B, C, D, E> Coarbitrary<P5<A, B, C, D, E>> coarbP5(final Coarbitrary<A> ca, final Coarbitrary<B> cb,
-                                                                       final Coarbitrary<C> cc, final Coarbitrary<D> cd,
-                                                                       final Coarbitrary<E> ce) {
-    return new Coarbitrary<P5<A, B, C, D, E>>() {
-      public <X> Gen<X> coarbitrary(final P5<A, B, C, D, E> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(),
-            cb.coarbitrary(p._2(), cc.coarbitrary(p._3(), cd.coarbitrary(p._4(), ce.coarbitrary(p._5(), g)))));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-6 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-6 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-6 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-6 is defined.
-   * @param cd A coarbitrary for one of the types over which the product-6 is defined.
-   * @param ce A coarbitrary for one of the types over which the product-6 is defined.
-   * @param cf A coarbitrary for one of the types over which the product-6 is defined.
-   * @return A coarbitrary for product-6 values.
-   */
-  public static <A, B, C, D, E, F$> Coarbitrary<P6<A, B, C, D, E, F$>> coarbP6(final Coarbitrary<A> ca,
-                                                                               final Coarbitrary<B> cb,
-                                                                               final Coarbitrary<C> cc,
-                                                                               final Coarbitrary<D> cd,
-                                                                               final Coarbitrary<E> ce,
-                                                                               final Coarbitrary<F$> cf) {
-    return new Coarbitrary<P6<A, B, C, D, E, F$>>() {
-      public <X> Gen<X> coarbitrary(final P6<A, B, C, D, E, F$> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(),
-            cc.coarbitrary(p._3(), cd.coarbitrary(p._4(), ce.coarbitrary(p._5(), cf.coarbitrary(p._6(), g))))));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-7 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-7 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-7 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-7 is defined.
-   * @param cd A coarbitrary for one of the types over which the product-7 is defined.
-   * @param ce A coarbitrary for one of the types over which the product-7 is defined.
-   * @param cf A coarbitrary for one of the types over which the product-7 is defined.
-   * @param cg A coarbitrary for one of the types over which the product-7 is defined.
-   * @return A coarbitrary for product-7 values.
-   */
-  public static <A, B, C, D, E, F$, G> Coarbitrary<P7<A, B, C, D, E, F$, G>> coarbP7(final Coarbitrary<A> ca,
-                                                                                     final Coarbitrary<B> cb,
-                                                                                     final Coarbitrary<C> cc,
-                                                                                     final Coarbitrary<D> cd,
-                                                                                     final Coarbitrary<E> ce,
-                                                                                     final Coarbitrary<F$> cf,
-                                                                                     final Coarbitrary<G> cg) {
-    return new Coarbitrary<P7<A, B, C, D, E, F$, G>>() {
-      public <X> Gen<X> coarbitrary(final P7<A, B, C, D, E, F$, G> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(), cc.coarbitrary(p._3(),
-            cd.coarbitrary(p._4(), ce.coarbitrary(p._5(), cf.coarbitrary(p._6(), cg.coarbitrary(p._7(), g)))))));
-      }
-    };
-  }
-
-  /**
-   * A coarbitrary for product-8 values.
-   *
-   * @param ca A coarbitrary for one of the types over which the product-8 is defined.
-   * @param cb A coarbitrary for one of the types over which the product-8 is defined.
-   * @param cc A coarbitrary for one of the types over which the product-8 is defined.
-   * @param cd A coarbitrary for one of the types over which the product-8 is defined.
-   * @param ce A coarbitrary for one of the types over which the product-8 is defined.
-   * @param cf A coarbitrary for one of the types over which the product-8 is defined.
-   * @param cg A coarbitrary for one of the types over which the product-8 is defined.
-   * @param ch A coarbitrary for one of the types over which the product-8 is defined.
-   * @return A coarbitrary for product-8 values.
-   */
-  public static <A, B, C, D, E, F$, G, H> Coarbitrary<P8<A, B, C, D, E, F$, G, H>> coarbP8(final Coarbitrary<A> ca,
-                                                                                           final Coarbitrary<B> cb,
-                                                                                           final Coarbitrary<C> cc,
-                                                                                           final Coarbitrary<D> cd,
-                                                                                           final Coarbitrary<E> ce,
-                                                                                           final Coarbitrary<F$> cf,
-                                                                                           final Coarbitrary<G> cg,
-                                                                                           final Coarbitrary<H> ch) {
-    return new Coarbitrary<P8<A, B, C, D, E, F$, G, H>>() {
-      public <X> Gen<X> coarbitrary(final P8<A, B, C, D, E, F$, G, H> p, final Gen<X> g) {
-        return ca.coarbitrary(p._1(), cb.coarbitrary(p._2(), cc.coarbitrary(p._3(), cd.coarbitrary(p._4(),
-            ce.coarbitrary(p._5(), cf.coarbitrary(p._6(), cg.coarbitrary(p._7(), ch.coarbitrary(p._8(), g))))))));
-      }
-    };
-  }
-}
diff --git a/quickcheck/src/main/java/fj/test/Cogen.java b/quickcheck/src/main/java/fj/test/Cogen.java
new file mode 100644
index 00000000..c4c3b0a0
--- /dev/null
+++ b/quickcheck/src/main/java/fj/test/Cogen.java
@@ -0,0 +1,1184 @@
+package fj.test;
+
+import fj.*;
+
+import static fj.Function.curry;
+import static fj.P.p;
+
+import fj.data.*;
+
+import static fj.data.Array.array;
+import static fj.data.Array.iterableArray;
+import static fj.data.List.fromString;
+import static fj.data.List.nil;
+
+import static fj.test.Variant.variant;
+
+import static java.lang.Double.doubleToRawLongBits;
+import static java.lang.Float.floatToRawIntBits;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Properties;
+import java.util.Stack;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.Vector;
+import java.util.WeakHashMap;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.DelayQueue;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+
+/**
+ * Transforms a type and a generator to produce a new generator. This function is used to generate
+ * {@link Gen gen} functions.
+ *
+ * @version %build.number%
+ */
+public abstract class Cogen<A> {
+  /**
+   * Transforms the given value and generator to a new generator with a high probability of being
+   * independent.
+   *
+   * @param a The value to produce the generator from.
+   * @param g The generator to produce the new generator from.
+   * @return A new generator with a high probability of being independent.
+   */
+  public abstract <B> Gen<B> cogen(A a, Gen<B> g);
+
+
+  /**
+   * A curried version of {@link #cogen(Object, Gen)}.
+   *
+   * @param a The value to produce the generator from.
+   * @return A curried version of {@link #cogen(Object, Gen)}.
+   */
+  public final <B> F<Gen<B>, Gen<B>> cogen(final A a) {
+    return g -> cogen(a, g);
+  }
+
+  /**
+   * Composes the given function with this cogen to produce a new cogen.
+   *
+   * @param f The function to compose.
+   * @return A new cogen composed with the given function.
+   */
+  public final <B> Cogen<B> compose(final F<B, A> f) {
+    return new Cogen<B>() {
+      public <X> Gen<X> cogen(final B b, final Gen<X> g) {
+        return Cogen.this.cogen(f.f(b), g);
+      }
+    };
+  }
+
+  /**
+   * Contra-maps this cogen using the given function.
+   *
+   * @param f The function to co-map with.
+   * @return A contra-mapped cogen.
+   */
+  public final <B> Cogen<B> contramap(final F<B, A> f) {
+    return new Cogen<B>() {
+      public <X> Gen<X> cogen(final B b, final Gen<X> g) {
+        return Cogen.this.cogen(f.f(b), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function.
+   *
+   * @param a A gen for the domain of the function.
+   * @param c A cogen for the codomain of the function.
+   * @return A cogen for a function.
+   */
+  public static <A, B> Cogen<F<A, B>> cogenF(final Gen<A> a, final Cogen<B> c) {
+    return new Cogen<F<A, B>>() {
+      public <X> Gen<X> cogen(final F<A, B> f, final Gen<X> g) {
+        return a.bind(a1 -> c.cogen(f.f(a1), g));
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-2.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-2.
+   */
+  public static <A, B, C> Cogen<F2<A, B, C>> cogenF2(final Gen<A> aa, final Gen<B> ab,
+                                                     final Cogen<C> c) {
+    return new Cogen<F2<A, B, C>>() {
+      public <X> Gen<X> cogen(final F2<A, B, C> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, c)).cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-3.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-3.
+   */
+  public static <A, B, C, D> Cogen<F3<A, B, C, D>> cogenF3(final Gen<A> aa, final Gen<B> ab,
+                                                           final Gen<C> ac, final Cogen<D> c) {
+    return new Cogen<F3<A, B, C, D>>() {
+      public <X> Gen<X> cogen(final F3<A, B, C, D> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, c))).cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-4.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param ad A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-4.
+   */
+  public static <A, B, C, D, E> Cogen<F4<A, B, C, D, E>> cogenF4(final Gen<A> aa, final Gen<B> ab,
+                                                                 final Gen<C> ac, final Gen<D> ad,
+                                                                 final Cogen<E> c) {
+    return new Cogen<F4<A, B, C, D, E>>() {
+      public <X> Gen<X> cogen(final F4<A, B, C, D, E> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, cogenF(ad, c)))).cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-5.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param ad A gen for part of the domain of the function.
+   * @param ae A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-5.
+   */
+  public static <A, B, C, D, E, F$> Cogen<F5<A, B, C, D, E, F$>> cogenF5(final Gen<A> aa,
+                                                                         final Gen<B> ab,
+                                                                         final Gen<C> ac,
+                                                                         final Gen<D> ad,
+                                                                         final Gen<E> ae,
+                                                                         final Cogen<F$> c) {
+    return new Cogen<F5<A, B, C, D, E, F$>>() {
+      public <X> Gen<X> cogen(final F5<A, B, C, D, E, F$> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, cogenF(ad, cogenF(ae, c))))).cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-6.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param ad A gen for part of the domain of the function.
+   * @param ae A gen for part of the domain of the function.
+   * @param af A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-6.
+   */
+  public static <A, B, C, D, E, F$, G> Cogen<F6<A, B, C, D, E, F$, G>> cogenF6(final Gen<A> aa,
+                                                                               final Gen<B> ab,
+                                                                               final Gen<C> ac,
+                                                                               final Gen<D> ad,
+                                                                               final Gen<E> ae,
+                                                                               final Gen<F$> af,
+                                                                               final Cogen<G> c) {
+    return new Cogen<F6<A, B, C, D, E, F$, G>>() {
+      public <X> Gen<X> cogen(final F6<A, B, C, D, E, F$, G> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, cogenF(ad, cogenF(ae, cogenF(af, c)))))).cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-7.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param ad A gen for part of the domain of the function.
+   * @param ae A gen for part of the domain of the function.
+   * @param af A gen for part of the domain of the function.
+   * @param ag A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-7.
+   */
+  public static <A, B, C, D, E, F$, G, H> Cogen<F7<A, B, C, D, E, F$, G, H>> cogenF7(final Gen<A> aa,
+                                                                                     final Gen<B> ab,
+                                                                                     final Gen<C> ac,
+                                                                                     final Gen<D> ad,
+                                                                                     final Gen<E> ae,
+                                                                                     final Gen<F$> af,
+                                                                                     final Gen<G> ag,
+                                                                                     final Cogen<H> c) {
+    return new Cogen<F7<A, B, C, D, E, F$, G, H>>() {
+      public <X> Gen<X> cogen(final F7<A, B, C, D, E, F$, G, H> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, cogenF(ad, cogenF(ae, cogenF(af, cogenF(ag, c)))))))
+            .cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for a function-8.
+   *
+   * @param aa A gen for part of the domain of the function.
+   * @param ab A gen for part of the domain of the function.
+   * @param ac A gen for part of the domain of the function.
+   * @param ad A gen for part of the domain of the function.
+   * @param ae A gen for part of the domain of the function.
+   * @param af A gen for part of the domain of the function.
+   * @param ag A gen for part of the domain of the function.
+   * @param ah A gen for part of the domain of the function.
+   * @param c  A cogen for the codomain of the function.
+   * @return A cogen for a function-8.
+   */
+  public static <A, B, C, D, E, F$, G, H, I> Cogen<F8<A, B, C, D, E, F$, G, H, I>> cogenF8(final Gen<A> aa,
+                                                                                           final Gen<B> ab,
+                                                                                           final Gen<C> ac,
+                                                                                           final Gen<D> ad,
+                                                                                           final Gen<E> ae,
+                                                                                           final Gen<F$> af,
+                                                                                           final Gen<G> ag,
+                                                                                           final Gen<H> ah,
+                                                                                           final Cogen<I> c) {
+    return new Cogen<F8<A, B, C, D, E, F$, G, H, I>>() {
+      public <X> Gen<X> cogen(final F8<A, B, C, D, E, F$, G, H, I> f, final Gen<X> g) {
+        return cogenF(aa, cogenF(ab, cogenF(ac, cogenF(ad, cogenF(ae, cogenF(af, cogenF(ag, cogenF(ah, c))))))))
+            .cogen(curry(f), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for booleans.
+   */
+  public static final Cogen<Boolean> cogenBoolean = new Cogen<Boolean>() {
+    public <B> Gen<B> cogen(final Boolean b, final Gen<B> g) {
+      return variant(b ? 0 : 1, g);
+    }
+  };
+
+  /**
+   * A cogen for integers.
+   */
+  public static final Cogen<Integer> cogenInteger = new Cogen<Integer>() {
+    public <B> Gen<B> cogen(final Integer i, final Gen<B> g) {
+      return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
+    }
+  };
+
+  /**
+   * A cogen for bytes.
+   */
+  public static final Cogen<Byte> cogenByte = new Cogen<Byte>() {
+    public <B> Gen<B> cogen(final Byte b, final Gen<B> g) {
+      return variant(b >= 0 ? 2 * b : -2 * b + 1, g);
+    }
+  };
+
+  /**
+   * A cogen for shorts.
+   */
+  public static final Cogen<Short> cogenShort = new Cogen<Short>() {
+    public <B> Gen<B> cogen(final Short s, final Gen<B> g) {
+      return variant(s >= 0 ? 2 * s : -2 * s + 1, g);
+    }
+  };
+
+  /**
+   * A cogen for longs.
+   */
+  public static final Cogen<Long> cogenLong = new Cogen<Long>() {
+    public <B> Gen<B> cogen(final Long l, final Gen<B> g) {
+      return variant(l >= 0L ? 2L * l : -2L * l + 1L, g);
+    }
+  };
+
+  /**
+   * A cogen for characters.
+   */
+  public static final Cogen<Character> cogenCharacter = new Cogen<Character>() {
+    public <B> Gen<B> cogen(final Character c, final Gen<B> g) {
+      return variant(c << 1, g);
+    }
+  };
+
+  /**
+   * A cogen for floats.
+   */
+  public static final Cogen<Float> cogenFloat = new Cogen<Float>() {
+    public <B> Gen<B> cogen(final Float f, final Gen<B> g) {
+      return cogenInteger.cogen(floatToRawIntBits(f), g);
+    }
+  };
+
+  /**
+   * A cogen for doubles.
+   */
+  public static final Cogen<Double> cogenDouble = new Cogen<Double>() {
+    public <B> Gen<B> cogen(final Double d, final Gen<B> g) {
+      return cogenLong.cogen(doubleToRawLongBits(d), g);
+    }
+  };
+
+  /**
+   * A cogen for the optional value.
+   *
+   * @param ca A cogen for the type of the optional value.
+   * @return A cogen for the optional value.
+   */
+  public static <A> Cogen<Option<A>> cogenOption(final Cogen<A> ca) {
+    return new Cogen<Option<A>>() {
+      public <B> Gen<B> cogen(final Option<A> o, final Gen<B> g) {
+        return o.isNone() ? variant(0, g) : variant(1, ca.cogen(o.some(), g));
+      }
+    };
+  }
+
+  /**
+   * A cogen for the disjoint union.
+   *
+   * @param ca A cogen for one side of the disjoint union.
+   * @param cb A cogen for one side of the disjoint union.
+   * @return A cogen for the disjoint union.
+   */
+  public static <A, B> Cogen<Either<A, B>> cogenEither(final Cogen<A> ca, final Cogen<B> cb) {
+    return new Cogen<Either<A, B>>() {
+      public <X> Gen<X> cogen(final Either<A, B> e, final Gen<X> g) {
+        return e.isLeft() ?
+            variant(0, ca.cogen(e.left().value(), g)) :
+            variant(1, cb.cogen(e.right().value(), g));
+      }
+    };
+  }
+
+  /**
+   * A cogen for lists.
+   *
+   * @param ca A cogen for the elements of the list.
+   * @return A cogen for lists.
+   */
+  public static <A> Cogen<List<A>> cogenList(final Cogen<A> ca) {
+    return new Cogen<List<A>>() {
+      public <B> Gen<B> cogen(final List<A> as, final Gen<B> g) {
+        return as.isEmpty() ?
+            variant(0, g) :
+            variant(1, ca.cogen(as.head(), cogen(as.tail(), g)));
+      }
+    };
+  }
+
+  /**
+   * A cogen for strings.
+   */
+  public static final Cogen<String> cogenString = new Cogen<String>() {
+    public <B> Gen<B> cogen(final String s, final Gen<B> g) {
+      return cogenList(cogenCharacter).cogen(fromString(s), g);
+    }
+  };
+
+  /**
+   * A cogen for string buffers.
+   */
+  public static final Cogen<StringBuffer> cogenStringBuffer = new Cogen<StringBuffer>() {
+    public <B> Gen<B> cogen(final StringBuffer s, final Gen<B> g) {
+      return cogenString.cogen(s.toString(), g);
+    }
+  };
+
+  /**
+   * A cogen for string builders.
+   */
+  public static final Cogen<StringBuilder> cogenStringBuilder = new Cogen<StringBuilder>() {
+    public <B> Gen<B> cogen(final StringBuilder s, final Gen<B> g) {
+      return cogenString.cogen(s.toString(), g);
+    }
+  };
+
+  /**
+   * A cogen for streams.
+   *
+   * @param ca A cogen for the elements of the stream.
+   * @return A cogen for streams.
+   */
+  public static <A> Cogen<Stream<A>> cogenStream(final Cogen<A> ca) {
+    return new Cogen<Stream<A>>() {
+      public <B> Gen<B> cogen(final Stream<A> as, final Gen<B> g) {
+        return as.isEmpty() ?
+            variant(0, g) :
+            variant(1, ca.cogen(as.head(), cogen(as.tail()._1(), g)));
+      }
+    };
+  }
+
+  /**
+   * A cogen for the provided LcgRng
+   * @return A cogen for the provided LcgRng.
+   */
+  public static Cogen<LcgRng> cogenLcgRng() {
+    return new Cogen<LcgRng>() {
+      @Override
+      public <B> Gen<B> cogen(LcgRng rng, Gen<B> g) {
+        long i = rng.getSeed();
+        return variant(i >= 0 ? 2 * i : -2 * i + 1, g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for state.
+   */
+  public static <S, A> Cogen<State<S, A>> cogenState(Gen<S> as, F2<S, A, Long> f) {
+    return new Cogen<State<S, A>>() {
+      @Override
+      public <B> Gen<B> cogen(State<S, A> s1, Gen<B> g) {
+        return as.bind(r -> {
+          P2<S, A> p = s1.run(r);
+          return variant(f.f(p._1(), p._2()), g);
+        });
+      }
+    };
+  }
+
+  /**
+   * A cogen for arrays.
+   *
+   * @param ca A cogen for the elements of the array.
+   * @return A cogen for arrays.
+   */
+  public static <A> Cogen<Array<A>> cogenArray(final Cogen<A> ca) {
+    return new Cogen<Array<A>>() {
+      public <B> Gen<B> cogen(final Array<A> as, final Gen<B> g) {
+        return cogenList(ca).cogen(as.toList(), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for throwables.
+   *
+   * @param cs A cogen for the throwable message.
+   * @return A cogen for throwables.
+   */
+  public static Cogen<Throwable> cogenThrowable(final Cogen<String> cs) {
+    return cs.contramap(new F<Throwable, String>() {
+      public String f(final Throwable t) {
+        return t.getMessage();
+      }
+    });
+  }
+
+  /**
+   * A cogen for throwables.
+   */
+  public static final Cogen<Throwable> cogenThrowable =
+      cogenThrowable(cogenString);
+
+  // BEGIN java.util
+
+  /**
+   * A cogen for array lists.
+   *
+   * @param ca A cogen for the elements of the array list.
+   * @return A cogen for array lists.
+   */
+  public static <A> Cogen<ArrayList<A>> cogenArrayList(final Cogen<A> ca) {
+    return new Cogen<ArrayList<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final ArrayList<A> as, final Gen<B> g) {
+        return cogenArray(ca).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for bit sets.
+   */
+  public static final Cogen<BitSet> cogenBitSet = new Cogen<BitSet>() {
+    public <B> Gen<B> cogen(final BitSet s, final Gen<B> g) {
+      List<Boolean> x = nil();
+
+      for (int i = 0; i < s.size(); i++) {
+        x = x.snoc(s.get(i));
+      }
+
+      return cogenList(cogenBoolean).cogen(x, g);
+    }
+  };
+
+  /**
+   * A cogen for calendars.
+   */
+  public static final Cogen<Calendar> cogenCalendar = new Cogen<Calendar>() {
+    public <B> Gen<B> cogen(final Calendar c, final Gen<B> g) {
+      return cogenLong.cogen(c.getTime().getTime(), g);
+    }
+  };
+
+  /**
+   * A cogen for dates.
+   */
+  public static final Cogen<Date> cogenDate = new Cogen<Date>() {
+    public <B> Gen<B> cogen(final Date d, final Gen<B> g) {
+      return cogenLong.cogen(d.getTime(), g);
+    }
+  };
+
+  /**
+   * A cogen for enum maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for enum maps.
+   */
+  public static <K extends Enum<K>, V> Cogen<EnumMap<K, V>> cogenEnumMap(final Cogen<K> ck,
+                                                                         final Cogen<V> cv) {
+    return new Cogen<EnumMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final EnumMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for enum sets.
+   *
+   * @param c A cogen for the elements of the enum set.
+   * @return A cogen for enum sets.
+   */
+  public static <A extends Enum<A>> Cogen<EnumSet<A>> cogenEnumSet(final Cogen<A> c) {
+    return new Cogen<EnumSet<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final EnumSet<A> as, final Gen<B> g) {
+        return cogenHashSet(c).cogen(new HashSet<>(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for gregorian calendars.
+   */
+  public static final Cogen<GregorianCalendar> cogenGregorianCalendar = new Cogen<GregorianCalendar>() {
+    public <B> Gen<B> cogen(final GregorianCalendar c, final Gen<B> g) {
+      return cogenLong.cogen(c.getTime().getTime(), g);
+    }
+  };
+
+  /**
+   * A cogen for hash maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for hash maps.
+   */
+  public static <K, V> Cogen<HashMap<K, V>> cogenHashMap(final Cogen<K> ck, final Cogen<V> cv) {
+    return new Cogen<HashMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final HashMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for hash sets.
+   *
+   * @param c A cogen for the elements of the hash set.
+   * @return A cogen for hash sets.
+   */
+  public static <A> Cogen<HashSet<A>> cogenHashSet(final Cogen<A> c) {
+    return new Cogen<HashSet<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final HashSet<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for hash tables.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for hash tables.
+   */
+  public static <K, V> Cogen<Hashtable<K, V>> cogenHashtable(final Cogen<K> ck, final Cogen<V> cv) {
+    return new Cogen<Hashtable<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final Hashtable<K, V> h, final Gen<B> g) {
+        List<P2<K, V>> x = nil();
+
+        for (final Map.Entry<K, V> entry : h.entrySet()) {
+          x = x.snoc(p(entry.getKey(), entry.getValue()));
+        }
+
+        return cogenList(cogenP2(ck, cv)).cogen(x, g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for identity hash maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for identity hash maps.
+   */
+  public static <K, V> Cogen<IdentityHashMap<K, V>> cogenIdentityHashMap(final Cogen<K> ck,
+                                                                         final Cogen<V> cv) {
+    return new Cogen<IdentityHashMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final IdentityHashMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for linked hash maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for linked hash maps.
+   */
+  public static <K, V> Cogen<LinkedHashMap<K, V>> cogenLinkedHashMap(final Cogen<K> ck,
+                                                                     final Cogen<V> cv) {
+    return new Cogen<LinkedHashMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final LinkedHashMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for linked hash sets.
+   *
+   * @param c A cogen for the elements of the linked hash set.
+   * @return A cogen for linked hash sets.
+   */
+  public static <A> Cogen<LinkedHashSet<A>> cogenLinkedHashSet(final Cogen<A> c) {
+    return new Cogen<LinkedHashSet<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final LinkedHashSet<A> as, final Gen<B> g) {
+        return cogenHashSet(c).cogen(new HashSet<>(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for linked lists.
+   *
+   * @param c A cogen for the elements of the linked list.
+   * @return A cogen for linked lists.
+   */
+  public static <A> Cogen<LinkedList<A>> cogenLinkedList(final Cogen<A> c) {
+    return new Cogen<LinkedList<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final LinkedList<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for priority queues.
+   *
+   * @param c A cogen for the elements of the priority queue.
+   * @return A cogen for priority queues.
+   */
+  public static <A> Cogen<PriorityQueue<A>> cogenPriorityQueue(final Cogen<A> c) {
+    return new Cogen<PriorityQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final PriorityQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for properties.
+   */
+  public static final Cogen<Properties> cogenProperties = new Cogen<Properties>() {
+    @SuppressWarnings("UseOfObsoleteCollectionType")
+    public <B> Gen<B> cogen(final Properties p, final Gen<B> g) {
+      final Hashtable<String, String> t = new Hashtable<>();
+
+      for (final Object s : p.keySet()) {
+        t.put((String) s, p.getProperty((String) s));
+      }
+
+      return cogenHashtable(cogenString, cogenString).cogen(t, g);
+    }
+  };
+
+  /**
+   * A cogen for stacks.
+   *
+   * @param c A cogen for the elements of the stack.
+   * @return A cogen for stacks.
+   */
+  public static <A> Cogen<Stack<A>> cogenStack(final Cogen<A> c) {
+    return new Cogen<Stack<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final Stack<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for tree maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for tree maps.
+   */
+  public static <K, V> Cogen<TreeMap<K, V>> cogenTreeMap(final Cogen<K> ck, final Cogen<V> cv) {
+    return new Cogen<TreeMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final TreeMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for tree sets.
+   *
+   * @param c A cogen for the elements of the tree set.
+   * @return A cogen for tree sets.
+   */
+  public static <A> Cogen<TreeSet<A>> cogenTreeSet(final Cogen<A> c) {
+    return new Cogen<TreeSet<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final TreeSet<A> as, final Gen<B> g) {
+        return cogenHashSet(c).cogen(new HashSet<>(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for vectors.
+   *
+   * @param c A cogen for the elements of the vector.
+   * @return A cogen for vectors.
+   */
+  public static <A> Cogen<Vector<A>> cogenVector(final Cogen<A> c) {
+    return new Cogen<Vector<A>>() {
+      @SuppressWarnings({"unchecked", "UseOfObsoleteCollectionType"})
+      public <B> Gen<B> cogen(final Vector<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for weak hash maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for weak hash maps.
+   */
+  public static <K, V> Cogen<WeakHashMap<K, V>> cogenWeakHashMap(final Cogen<K> ck,
+                                                                 final Cogen<V> cv) {
+    return new Cogen<WeakHashMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final WeakHashMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  // END java.util
+
+  // BEGIN java.util.concurrent
+
+  /**
+   * A cogen for array blocking queues.
+   *
+   * @param c A cogen for the elements of the array blocking queue.
+   * @return A cogen for array blocking queues.
+   */
+  public static <A> Cogen<ArrayBlockingQueue<A>> cogenArrayBlockingQueue(final Cogen<A> c) {
+    return new Cogen<ArrayBlockingQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final ArrayBlockingQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for concurrent hash maps.
+   *
+   * @param ck A cogen for the map keys.
+   * @param cv A cogen for the map values.
+   * @return A cogen for concurrent hash maps.
+   */
+  public static <K, V> Cogen<ConcurrentHashMap<K, V>> cogenConcurrentHashMap(final Cogen<K> ck,
+                                                                             final Cogen<V> cv) {
+    return new Cogen<ConcurrentHashMap<K, V>>() {
+      @SuppressWarnings("UseOfObsoleteCollectionType")
+      public <B> Gen<B> cogen(final ConcurrentHashMap<K, V> m, final Gen<B> g) {
+        return cogenHashtable(ck, cv).cogen(new Hashtable<>(m), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for concurrent linked queues.
+   *
+   * @param c A cogen for the elements of the concurrent linked queue.
+   * @return A cogen for concurrent linked queues.
+   */
+  public static <A> Cogen<ConcurrentLinkedQueue<A>> cogenConcurrentLinkedQueue(final Cogen<A> c) {
+    return new Cogen<ConcurrentLinkedQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final ConcurrentLinkedQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for copy-on-write array lists.
+   *
+   * @param c A cogen for the elements of the copy-on-write array list.
+   * @return A cogen for copy-on-write array lists.
+   */
+  public static <A> Cogen<CopyOnWriteArrayList<A>> cogenCopyOnWriteArrayList(final Cogen<A> c) {
+    return new Cogen<CopyOnWriteArrayList<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final CopyOnWriteArrayList<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for copy-on-write array sets.
+   *
+   * @param c A cogen for the elements of the copy-on-write array set.
+   * @return A cogen for copy-on-write array sets.
+   */
+  public static <A> Cogen<CopyOnWriteArraySet<A>> cogenCopyOnWriteArraySet(final Cogen<A> c) {
+    return new Cogen<CopyOnWriteArraySet<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final CopyOnWriteArraySet<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for delay queues.
+   *
+   * @param c A cogen for the elements of the delay queue.
+   * @return A cogen for delay queues.
+   */
+  public static <A extends Delayed> Cogen<DelayQueue<A>> cogenDelayQueue(final Cogen<A> c) {
+    return new Cogen<DelayQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final DelayQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for linked blocking queues.
+   *
+   * @param c A cogen for the elements of the linked blocking queue.
+   * @return A cogen for linked blocking queues.
+   */
+  public static <A> Cogen<LinkedBlockingQueue<A>> cogenLinkedBlockingQueue(final Cogen<A> c) {
+    return new Cogen<LinkedBlockingQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final LinkedBlockingQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for priority blocking queues.
+   *
+   * @param c A cogen for the elements of the priority blocking queue.
+   * @return A cogen for priority blocking queues.
+   */
+  public static <A> Cogen<PriorityBlockingQueue<A>> cogenPriorityBlockingQueue(final Cogen<A> c) {
+    return new Cogen<PriorityBlockingQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final PriorityBlockingQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for synchronous queues.
+   *
+   * @param c A cogen for the elements of the synchronous queue.
+   * @return A cogen for synchronous queues.
+   */
+  public static <A> Cogen<SynchronousQueue<A>> cogenSynchronousQueue(final Cogen<A> c) {
+    return new Cogen<SynchronousQueue<A>>() {
+      @SuppressWarnings("unchecked")
+      public <B> Gen<B> cogen(final SynchronousQueue<A> as, final Gen<B> g) {
+        return cogenArray(c).cogen(iterableArray(as), g);
+      }
+    };
+  }
+
+  // END java.util.concurrent
+
+  // BEGIN java.sql
+
+  public static final Cogen<java.sql.Date> cogenSQLDate = new Cogen<java.sql.Date>() {
+    public <B> Gen<B> cogen(final java.sql.Date d, final Gen<B> g) {
+      return cogenLong.cogen(d.getTime(), g);
+    }
+  };
+
+  public static final Cogen<Timestamp> cogenTimestamp = new Cogen<Timestamp>() {
+    public <B> Gen<B> cogen(final Timestamp t, final Gen<B> g) {
+      return cogenLong.cogen(t.getTime(), g);
+    }
+  };
+
+  public static final Cogen<Time> cogenTime = new Cogen<Time>() {
+    public <B> Gen<B> cogen(final Time t, final Gen<B> g) {
+      return cogenLong.cogen(t.getTime(), g);
+    }
+  };
+
+  // END java.sql
+
+  // BEGIN java.math
+
+  public static final Cogen<BigInteger> cogenBigInteger = new Cogen<BigInteger>() {
+    public <B> Gen<B> cogen(final BigInteger i, final Gen<B> g) {
+      return variant((i.compareTo(BigInteger.ZERO) >= 0 ?
+          i.multiply(BigInteger.valueOf(2L)) :
+          i.multiply(BigInteger.valueOf(-2L).add(BigInteger.ONE))).longValue(), g);
+    }
+  };
+
+  public static final Cogen<BigDecimal> cogenBigDecimal = new Cogen<BigDecimal>() {
+    public <B> Gen<B> cogen(final BigDecimal d, final Gen<B> g) {
+      return variant((d.compareTo(BigDecimal.ZERO) >= 0 ?
+          d.multiply(BigDecimal.valueOf(2L)) :
+          d.multiply(BigDecimal.valueOf(-2L).add(BigDecimal.ONE))).longValue(), g);
+    }
+  };
+
+  // END java.math
+
+  /**
+   * A cogen for product-1 values.
+   *
+   * @param ca A cogen for one of the types over which the product-1 is defined.
+   * @return A cogen for product-1 values.
+   */
+  public static <A> Cogen<P1<A>> cogenP1(final Cogen<A> ca) {
+    return new Cogen<P1<A>>() {
+      public <B> Gen<B> cogen(final P1<A> p, final Gen<B> g) {
+        return ca.cogen(p._1(), g);
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-2 values.
+   *
+   * @param ca A cogen for one of the types over which the product-2 is defined.
+   * @param cb A cogen for one of the types over which the product-2 is defined.
+   * @return A cogen for product-2 values.
+   */
+  public static <A, B> Cogen<P2<A, B>> cogenP2(final Cogen<A> ca, final Cogen<B> cb) {
+    return new Cogen<P2<A, B>>() {
+      public <X> Gen<X> cogen(final P2<A, B> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(), g));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-3 values.
+   *
+   * @param ca A cogen for one of the types over which the product-3 is defined.
+   * @param cb A cogen for one of the types over which the product-3 is defined.
+   * @param cc A cogen for one of the types over which the product-3 is defined.
+   * @return A cogen for product-3 values.
+   */
+  public static <A, B, C> Cogen<P3<A, B, C>> cogenP3(final Cogen<A> ca, final Cogen<B> cb,
+                                                     final Cogen<C> cc) {
+    return new Cogen<P3<A, B, C>>() {
+      public <X> Gen<X> cogen(final P3<A, B, C> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(), cc.cogen(p._3(), g)));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-4 values.
+   *
+   * @param ca A cogen for one of the types over which the product-4 is defined.
+   * @param cb A cogen for one of the types over which the product-4 is defined.
+   * @param cc A cogen for one of the types over which the product-4 is defined.
+   * @param cd A cogen for one of the types over which the product-4 is defined.
+   * @return A cogen for product-4 values.
+   */
+  public static <A, B, C, D> Cogen<P4<A, B, C, D>> cogenP4(final Cogen<A> ca, final Cogen<B> cb,
+                                                           final Cogen<C> cc, final Cogen<D> cd) {
+    return new Cogen<P4<A, B, C, D>>() {
+      public <X> Gen<X> cogen(final P4<A, B, C, D> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(), cc.cogen(p._3(), cd.cogen(p._4(), g))));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-5 values.
+   *
+   * @param ca A cogen for one of the types over which the product-5 is defined.
+   * @param cb A cogen for one of the types over which the product-5 is defined.
+   * @param cc A cogen for one of the types over which the product-5 is defined.
+   * @param cd A cogen for one of the types over which the product-5 is defined.
+   * @param ce A cogen for one of the types over which the product-5 is defined.
+   * @return A cogen for product-5 values.
+   */
+  public static <A, B, C, D, E> Cogen<P5<A, B, C, D, E>> cogenP5(final Cogen<A> ca, final Cogen<B> cb,
+                                                                 final Cogen<C> cc, final Cogen<D> cd,
+                                                                 final Cogen<E> ce) {
+    return new Cogen<P5<A, B, C, D, E>>() {
+      public <X> Gen<X> cogen(final P5<A, B, C, D, E> p, final Gen<X> g) {
+        return ca.cogen(p._1(),
+            cb.cogen(p._2(), cc.cogen(p._3(), cd.cogen(p._4(), ce.cogen(p._5(), g)))));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-6 values.
+   *
+   * @param ca A cogen for one of the types over which the product-6 is defined.
+   * @param cb A cogen for one of the types over which the product-6 is defined.
+   * @param cc A cogen for one of the types over which the product-6 is defined.
+   * @param cd A cogen for one of the types over which the product-6 is defined.
+   * @param ce A cogen for one of the types over which the product-6 is defined.
+   * @param cf A cogen for one of the types over which the product-6 is defined.
+   * @return A cogen for product-6 values.
+   */
+  public static <A, B, C, D, E, F$> Cogen<P6<A, B, C, D, E, F$>> cogenP6(final Cogen<A> ca,
+                                                                         final Cogen<B> cb,
+                                                                         final Cogen<C> cc,
+                                                                         final Cogen<D> cd,
+                                                                         final Cogen<E> ce,
+                                                                         final Cogen<F$> cf) {
+    return new Cogen<P6<A, B, C, D, E, F$>>() {
+      public <X> Gen<X> cogen(final P6<A, B, C, D, E, F$> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(),
+            cc.cogen(p._3(), cd.cogen(p._4(), ce.cogen(p._5(), cf.cogen(p._6(), g))))));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-7 values.
+   *
+   * @param ca A cogen for one of the types over which the product-7 is defined.
+   * @param cb A cogen for one of the types over which the product-7 is defined.
+   * @param cc A cogen for one of the types over which the product-7 is defined.
+   * @param cd A cogen for one of the types over which the product-7 is defined.
+   * @param ce A cogen for one of the types over which the product-7 is defined.
+   * @param cf A cogen for one of the types over which the product-7 is defined.
+   * @param cg A cogen for one of the types over which the product-7 is defined.
+   * @return A cogen for product-7 values.
+   */
+  public static <A, B, C, D, E, F$, G> Cogen<P7<A, B, C, D, E, F$, G>> cogenP7(final Cogen<A> ca,
+                                                                               final Cogen<B> cb,
+                                                                               final Cogen<C> cc,
+                                                                               final Cogen<D> cd,
+                                                                               final Cogen<E> ce,
+                                                                               final Cogen<F$> cf,
+                                                                               final Cogen<G> cg) {
+    return new Cogen<P7<A, B, C, D, E, F$, G>>() {
+      public <X> Gen<X> cogen(final P7<A, B, C, D, E, F$, G> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(), cc.cogen(p._3(),
+            cd.cogen(p._4(), ce.cogen(p._5(), cf.cogen(p._6(), cg.cogen(p._7(), g)))))));
+      }
+    };
+  }
+
+  /**
+   * A cogen for product-8 values.
+   *
+   * @param ca A cogen for one of the types over which the product-8 is defined.
+   * @param cb A cogen for one of the types over which the product-8 is defined.
+   * @param cc A cogen for one of the types over which the product-8 is defined.
+   * @param cd A cogen for one of the types over which the product-8 is defined.
+   * @param ce A cogen for one of the types over which the product-8 is defined.
+   * @param cf A cogen for one of the types over which the product-8 is defined.
+   * @param cg A cogen for one of the types over which the product-8 is defined.
+   * @param ch A cogen for one of the types over which the product-8 is defined.
+   * @return A cogen for product-8 values.
+   */
+  public static <A, B, C, D, E, F$, G, H> Cogen<P8<A, B, C, D, E, F$, G, H>> cogenP8(final Cogen<A> ca,
+                                                                                     final Cogen<B> cb,
+                                                                                     final Cogen<C> cc,
+                                                                                     final Cogen<D> cd,
+                                                                                     final Cogen<E> ce,
+                                                                                     final Cogen<F$> cf,
+                                                                                     final Cogen<G> cg,
+                                                                                     final Cogen<H> ch) {
+    return new Cogen<P8<A, B, C, D, E, F$, G, H>>() {
+      public <X> Gen<X> cogen(final P8<A, B, C, D, E, F$, G, H> p, final Gen<X> g) {
+        return ca.cogen(p._1(), cb.cogen(p._2(), cc.cogen(p._3(), cd.cogen(p._4(),
+            ce.cogen(p._5(), cf.cogen(p._6(), cg.cogen(p._7(), ch.cogen(p._8(), g))))))));
+      }
+    };
+  }
+}
diff --git a/quickcheck/src/test/java/fj/data/test/TestCheck.java b/quickcheck/src/test/java/fj/data/test/TestCheck.java
index 6bfaeaf7..935f1127 100644
--- a/quickcheck/src/test/java/fj/data/test/TestCheck.java
+++ b/quickcheck/src/test/java/fj/data/test/TestCheck.java
@@ -11,8 +11,6 @@
 
 import static fj.Function.compose;
 import static fj.test.Arbitrary.arbLong;
-import static fj.test.Coarbitrary.coarbInteger;
-import static fj.test.Coarbitrary.coarbLong;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.junit.Assert.*;
diff --git a/quickcheck/src/test/java/fj/data/test/TestNull.java b/quickcheck/src/test/java/fj/data/test/TestNull.java
index 0346407d..0fd44c6a 100644
--- a/quickcheck/src/test/java/fj/data/test/TestNull.java
+++ b/quickcheck/src/test/java/fj/data/test/TestNull.java
@@ -11,8 +11,6 @@
 
 import static fj.Function.compose;
 import static fj.test.Arbitrary.arbLong;
-import static fj.test.Coarbitrary.coarbInteger;
-import static fj.test.Coarbitrary.coarbLong;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 

From e87d5be36daac7f52ffd44bb99a04ee13666fdee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 6 Jun 2016 20:26:23 -0400
Subject: [PATCH 082/336] Add DB.db method with Try1

---
 core/src/main/java/fj/control/db/DB.java      | 16 ++++++++++++
 .../test/java/fj/control/db/TestDbState.java  | 25 +++++++++----------
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/fj/control/db/DB.java b/core/src/main/java/fj/control/db/DB.java
index a7ba6a7f..4e16710e 100644
--- a/core/src/main/java/fj/control/db/DB.java
+++ b/core/src/main/java/fj/control/db/DB.java
@@ -2,6 +2,7 @@
 
 import fj.F;
 import fj.Function;
+import fj.function.Try1;
 
 import java.sql.Connection;
 import java.sql.SQLException;
@@ -35,6 +36,21 @@ public A run(final Connection c) {
     };
   }
 
+  /**
+   * Constructs a database action as a function from a database connection to a value.
+   *
+   * @param t A function from a database connection to a value allowed to throw
+   *          SQLException
+   * @return A database action representing the given function.
+   */
+  public static <A> DB<A> db(final Try1<Connection, A, SQLException> t){
+    return new DB<A>() {
+      public A run(final Connection c) throws SQLException {
+        return t.f(c);
+      }
+    };
+  }
+
   /**
    * Returns the callable-valued function projection of this database action.
    *
diff --git a/core/src/test/java/fj/control/db/TestDbState.java b/core/src/test/java/fj/control/db/TestDbState.java
index 00933921..188eae3d 100644
--- a/core/src/test/java/fj/control/db/TestDbState.java
+++ b/core/src/test/java/fj/control/db/TestDbState.java
@@ -2,6 +2,7 @@
 
 import fj.Unit;
 import fj.data.Option;
+import fj.function.Try1;
 import org.apache.commons.dbutils.DbUtils;
 import org.junit.Test;
 
@@ -16,20 +17,18 @@ public void testWriter() throws SQLException {
         final int TEN = 10;
         DbState writer = DbState.writer(DbState.driverManager("jdbc:h2:mem:"));
 
-        DB<Unit> setup = new DB<Unit>() {
-            @Override
-            public Unit run(Connection c) throws SQLException {
-                Statement s = null;
-                try {
-                    s = c.createStatement();
-                    assertThat(s.executeUpdate("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))"), is(0));
-                    assertThat(s.executeUpdate("INSERT INTO TEST (ID, NAME) VALUES (" + TEN + ", 'FOO')"), is(1));
-                } finally {
-                    DbUtils.closeQuietly(s);
-                }
-                return Unit.unit();
+        DB<Unit> setup = DB.db((Try1<Connection, Unit, SQLException>) c -> {
+            Statement s = null;
+            try {
+                s = c.createStatement();
+                assertThat(s.executeUpdate("CREATE TABLE TEST(ID INT PRIMARY KEY, NAME VARCHAR(255))"), is(0));
+                assertThat(s.executeUpdate("INSERT INTO TEST (ID, NAME) VALUES (" + TEN + ", 'FOO')"), is(1));
+            } finally {
+                DbUtils.closeQuietly(s);
             }
-        };
+            return Unit.unit();
+        });
+
         DB<Option<Integer>> query = new DB<Option<Integer>>() {
             @Override
             public Option<Integer> run(Connection c) throws SQLException {

From bcc0b711fbaaeed4912912ff7e8b569025ef446c Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 14 Jun 2016 07:55:24 +0200
Subject: [PATCH 083/336] Remove extra type parameters on methods in P2.Optic.
 Fix #273

---
 core/src/main/java/fj/P2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index 521fc14d..abe4d0d5 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -335,7 +335,7 @@ public static <A, B, C> PLens<P2<A, B>, P2<C, B>, A, C> _1p() {
     /**
      * Monomorphic lens targeted on _1.
      */
-    public static <A, B, C> Lens<P2<A, B>, A> _1() {
+    public static <A, B> Lens<P2<A, B>, A> _1() {
       return new Lens<>(_1p());
     }
 
@@ -349,7 +349,7 @@ public static <A, B, C> PLens<P2<A, B>, P2<A, C>, B, C> _2p() {
     /**
      * Monomorphic lens targeted on _1.
      */
-    public static <A, B, C> Lens<P2<A, B>, B> _2() {
+    public static <A, B> Lens<P2<A, B>, B> _2() {
       return new Lens<>(_2p());
     }
 

From 7a9f3d98c6f7f42eb567d237375ed1d2188b4fe6 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 14 Jun 2016 08:17:12 +0200
Subject: [PATCH 084/336] Document version deprecated for toJavaArray methods.
 Fix  #264 Also suppress unchecked warnings (#269) for them.

---
 core/src/main/java/fj/data/Array.java  | 3 ++-
 core/src/main/java/fj/data/List.java   | 3 ++-
 core/src/main/java/fj/data/Stream.java | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index b6538ba5..7e937200 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -135,8 +135,9 @@ public Object[] array() {
    * affectation of the result of this method to a non generic array
    * will result in runtime error (ClassCastException).
    *
-   * @deprecated use {@link #array(Class)}
+   * @deprecated As of release 4.6, use {@link #array(Class)}.
    */
+  @SuppressWarnings("unchecked")
   @Deprecated
   public A[] toJavaArray() {
     return (A[]) array();
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index cfd95898..2b1a728e 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -216,8 +216,9 @@ public final Object[] toArrayObject() {
    * affectation of the result of this method to a non generic array
    * will result in runtime error (ClassCastException).
    *
-   * @deprecated use {@link #array(Class)}
+   * @deprecated As of release 4.6, use {@link #array(Class)}.
    */
+  @SuppressWarnings("unchecked")
   @Deprecated
   public final A[] toJavaArray() {
     return (A[]) toArrayObject();
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index 01e1756b..ca4c870a 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -922,10 +922,11 @@ public final Option<A> toOption() {
    * affectation of the result of this method to a non generic array
    * will result in runtime error (ClassCastException).
    *
-   * @deprecated use {@link #array(Class)}
+   * @deprecated As of release 4.6, use {@link #array(Class)}.
    */
   @Deprecated
   public final A[] toJavaArray() {
+    @SuppressWarnings("unchecked")
     final A[] array = (A[]) new Object[length()];
     int i = 0;
     for (A a: this) {

From 7b84ad992b2b651cad5158de3b5e1d011cbb96b5 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 14 Jun 2016 08:22:13 +0200
Subject: [PATCH 085/336] Fix unchecked conversion warnings. Fix #269.

---
 core/src/test/java/fj/ClassTest.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/test/java/fj/ClassTest.java b/core/src/test/java/fj/ClassTest.java
index 862c6fdd..2959e351 100644
--- a/core/src/test/java/fj/ClassTest.java
+++ b/core/src/test/java/fj/ClassTest.java
@@ -23,28 +23,28 @@ public void testInheritance() {
 
     @Test
     public void testClassParameters() {
-        Class c = Class.clas(Option.none().getClass());
+        Class<? extends Option> c = Class.clas(Option.none().getClass());
         Tree<Type> cp = c.classParameters();
         assertThat(cp.length(), is(1));
     }
 
     @Test
     public void testSuperclassParameters() {
-        Class c = Class.clas(Option.none().getClass());
+        Class<? extends Option> c = Class.clas(Option.none().getClass());
         Tree<Type> cp = c.superclassParameters();
         assertThat(cp.length(), is(2));
     }
 
     @Test
     public void testInterfaceParameters() {
-        Class c = Class.clas(Option.none().getClass());
-        List<Type> l =c.interfaceParameters();
+        Class<? extends Option> c = Class.clas(Option.none().getClass());
+        List<Tree<Type>> l =c.interfaceParameters();
         assertThat(l.length(), is(0));
     }
 
     @Test
     public void testTypeParameterTree() {
-        Class c = Class.clas(Option.none().getClass());
+        Class<? extends Option> c = Class.clas(Option.none().getClass());
         Collection<Type> coll = c.classParameters().toCollection();
         for (Type t: coll) {
             assertThat(Class.typeParameterTree(t).toString(), is("Tree(class fj.data.Option$None)"));

From 8eac39a9ebbff5082ef98bd70bcaf8cb25038a0a Mon Sep 17 00:00:00 2001
From: mrbackend <roy.brokvam@gmail.com>
Date: Mon, 6 Jun 2016 17:17:43 +0200
Subject: [PATCH 086/336] Stack safe State

---
 core/src/main/java/fj/data/State.java         | 213 ++++-----
 .../test/java/fj/data/StateProperties.java    | 409 ++++++++++++++++++
 2 files changed, 516 insertions(+), 106 deletions(-)
 create mode 100644 props-core/src/test/java/fj/data/StateProperties.java

diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 3128ae6c..1b30a55e 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -1,118 +1,119 @@
 package fj.data;
 
-import fj.*;
+import fj.F;
+import fj.P2;
+import fj.Unit;
+import fj.control.Trampoline;
 
+import static fj.P.lazy;
 import static fj.P.p;
+import static fj.control.Trampoline.suspend;
+import static fj.data.List.cons;
 
 /**
  * Created by MarkPerry on 7/07/2014.
  */
 public final class State<S, A> {
 
-	private final F<S, P2<S, A>> run;
-
-	private State(F<S, P2<S, A>> f) {
-		run = f;
-	}
-
-	public P2<S, A> run(S s) {
-		return run.f(s);
-	}
-
-	public static <S, A> State<S, A> unit(F<S, P2<S, A>> f) {
-		return new State<>(f);
-	}
-
-	public static <S> State<S, S> units(F<S, S> f) {
-		return unit((S s) -> {
-			S s2 = f.f(s);
-			return p(s2, s2);
-		});
-	}
-
-	public static <S, A> State<S, A> constant(A a) {
-		return unit(s -> p(s, a));
-	}
-
-	public <B> State<S, B> map(F<A, B> f) {
-		return unit((S s) -> {
-			P2<S, A> p2 = run(s);
-			B b = f.f(p2._2());
-			return p(p2._1(), b);
-		});
-	}
-
-	public static <S> State<S, Unit> modify(F<S, S> f) {
-		return State.<S>init().flatMap(s -> unit(s2 -> p(f.f(s), Unit.unit())));
-	}
-
-	public <B> State<S, B> mapState(F<P2<S, A>, P2<S, B>> f) {
-		return unit(s -> f.f(run(s)));
-	}
-
-	public static <S, B, C> State<S, C> flatMap(State<S, B> mb, F<B, State<S, C>> f) {
-		return mb.flatMap(f);
-	}
-
-	public <B> State<S, B> flatMap(F<A, State<S, B>> f) {
-		return unit((S s) -> {
-			P2<S, A> p = run(s);
-			A a = p._2();
-			S s2 = p._1();
-			State<S, B> smb = f.f(a);
-			return smb.run(s2);
-		});
-	}
-
-	public static <S> State<S, S> init() {
-		return unit(s -> p(s, s));
-	}
-
-	public State<S, S> gets() {
-		return unit(s -> {
-			P2<S, A> p = run(s);
-			S s2 = p._1();
-			return p(s2, s2);
-		});
-	}
-
-	public static <S> State<S, Unit> put(S s) {
-		return unit((S z) -> p(s, Unit.unit()));
-	}
-
-	public A eval(S s) {
-		return run(s)._2();
-	}
-
-	public S exec(S s) {
-		return run(s)._1();
-	}
-
-	public State<S, A> withs(F<S, S> f) {
-		return unit(F1Functions.andThen(f, run));
-	}
-
-	public static <S, A> State<S, A> gets(F<S, A> f) {
-		return State.<S>init().map(f);
-	}
-
-	/**
-	 * Evaluate each action in the sequence from left to right, and collect the results.
-	 */
-	public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
-		return list.foldLeft((State<S, List<A>> acc, State<S, A> ma) ->
-			acc.flatMap((List<A> xs) -> ma.map(xs::snoc)
-		), constant(List.nil()));
-	}
-
-	/**
-	 * Map each element of a structure to an action, evaluate these actions from left to right
-	 * and collect the results.
-	 */
-	public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B>> f) {
-		return list.foldLeft((State<S, List<B>> acc, A a) ->
-			acc.flatMap(bs -> f.f(a).map(bs::snoc)
-		), constant(List.nil()));
-	}
+  public static <S, A> State<S, A> unit(F<S, P2<S, A>> runF) {
+    return new State<>(s -> Trampoline.pure(runF.f(s)));
+  }
+
+  public static <S> State<S, S> init() {
+    return unit(s -> dup(s));
+  }
+
+  public static <S> State<S, S> units(F<S, S> f) {
+    return unit(s -> dup(f.f(s)));
+  }
+
+  private static <S> P2<S, S> dup(S s) {
+    return p(s, s);
+  }
+
+  public static <S, A> State<S, A> constant(A a) {
+    return unit(s -> p(s, a));
+  }
+
+  public static <S, A> State<S, A> gets(F<S, A> f) {
+    return unit(s -> p(s, f.f(s)));
+  }
+
+  public static <S> State<S, Unit> put(S s) {
+    return unit(ignoredS -> p(s, Unit.unit()));
+  }
+
+  public static <S> State<S, Unit> modify(F<S, S> f) {
+    return unit(s -> p(f.f(s), Unit.unit()));
+  }
+
+  public static <S, A, B> State<S, B> flatMap(State<S, A> ts, F<A, State<S, B>> f) {
+    return ts.flatMap(f);
+  }
+
+  /**
+   * Evaluate each action in the sequence from left to right, and collect the results.
+   */
+  public static <S, A> State<S, List<A>> sequence(List<State<S, A>> list) {
+    return list
+        .foldLeft(
+            (acc, ts) -> acc.flatMap(as -> ts.map(a -> cons(a, as))),
+            State.<S, List<A>>constant(List.nil()))
+        .map(as -> as.reverse());
+  }
+
+  /**
+   * Map each element of a structure to an action, evaluate these actions from left to right
+   * and collect the results.
+   */
+  public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B>> f) {
+    return list
+        .foldLeft(
+            (acc, a) -> acc.flatMap(bs -> f.f(a).map(b -> cons(b, bs))),
+            State.<S, List<B>>constant(List.nil()))
+        .map(bs -> bs.reverse());
+  }
+
+  private static <S, A> State<S, A> suspended(F<S, Trampoline<P2<S, A>>> runF) {
+    return new State<>(s -> suspend(lazy(() -> runF.f(s))));
+  }
+
+  private final F<S, Trampoline<P2<S, A>>> runF;
+
+  private State(F<S, Trampoline<P2<S, A>>> runF) {
+    this.runF = runF;
+  }
+
+  public P2<S, A> run(S s) {
+    return runF.f(s).run();
+  }
+
+  public A eval(S s) {
+    return run(s)._2();
+  }
+
+  public S exec(S s) {
+    return run(s)._1();
+  }
+
+  public State<S, S> gets() {
+    return mapState(result -> p(result._1(), result._1()));
+  }
+
+  public <B> State<S, B> map(F<A, B> f) {
+    return mapState(result -> p(result._1(), f.f(result._2())));
+  }
+
+  public <B> State<S, B> mapState(F<P2<S, A>, P2<S, B>> f) {
+    return suspended(s -> runF.f(s).map(result -> f.f(result)));
+  }
+
+  public State<S, A> withs(F<S, S> f) {
+    return suspended(s -> runF.f(f.f(s)));
+  }
+
+  public <B> State<S, B> flatMap(F<A, State<S, B>> f) {
+    return suspended(s -> runF.f(s).bind(result -> Trampoline.pure(f.f(result._2()).run(result._1()))));
+  }
 
 }
diff --git a/props-core/src/test/java/fj/data/StateProperties.java b/props-core/src/test/java/fj/data/StateProperties.java
new file mode 100644
index 00000000..3fb0e2ba
--- /dev/null
+++ b/props-core/src/test/java/fj/data/StateProperties.java
@@ -0,0 +1,409 @@
+package fj.data;
+
+import fj.F;
+import fj.P2;
+import fj.Unit;
+import fj.test.Arbitrary;
+import fj.test.Coarbitrary;
+import fj.test.Gen;
+import fj.test.Property;
+import fj.test.reflect.CheckParams;
+import fj.test.runner.PropertyTestRunner;
+import org.junit.runner.RunWith;
+
+import static fj.P.p;
+import static fj.data.List.range;
+import static fj.test.Arbitrary.arbF;
+import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbList;
+import static fj.test.Arbitrary.arbP2;
+import static fj.test.Arbitrary.arbitrary;
+import static fj.test.Coarbitrary.coarbInteger;
+import static fj.test.Coarbitrary.coarbP2;
+import static fj.test.Property.prop;
+import static fj.test.Property.property;
+
+@RunWith(PropertyTestRunner.class)
+public final class StateProperties {
+
+  public Property unit() {
+    return property(
+        arbRunF(coarbInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testUnit(runF, initS)));
+  }
+
+  private static <S, A> boolean testUnit(F<S, P2<S, A>> runF, S initS) {
+    State<S, A> instance = State.unit(runF);
+    P2<S, A> actual = instance.run(initS);
+    P2<S, A> expected = runF.f(initS);
+    return actual.equals(expected);
+  }
+
+  public Property init() {
+    return property(
+        arbInteger,
+        initS -> prop(testInit(initS)));
+  }
+
+  private static <S> boolean testInit(S initS) {
+    State<S, S> instance = State.init();
+    P2<S, S> actual = instance.run(initS);
+    P2<S, S> expected = p(initS, initS);
+    return actual.equals(expected);
+  }
+
+  public Property units() {
+    return property(
+        arbF(coarbInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testUnits(f, initS)));
+  }
+
+  private static <S> boolean testUnits(F<S, S> f, S initS) {
+    State<S, S> instance = State.units(f);
+    P2<S, S> actual = instance.run(initS);
+    S expectedS = f.f(initS);
+    P2<S, S> expected = p(expectedS, expectedS);
+    return actual.equals(expected);
+  }
+
+  public Property constant() {
+    return property(
+        arbInteger,
+        arbInteger,
+        (a, initS) -> prop(testConstant(a, initS)));
+  }
+
+  private static <S, A> boolean testConstant(A a, S initS) {
+    State<S, A> instance = State.constant(a);
+    P2<S, A> actual = instance.run(initS);
+    P2<S, A> expected = p(initS, a);
+    return actual.equals(expected);
+  }
+
+  public Property staticGets() {
+    return property(
+        arbF(coarbInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testStaticGets(f, initS)));
+  }
+
+  private static <S, A> boolean testStaticGets(F<S, A> f, S initS) {
+    State<S, A> instance = State.gets(f);
+    P2<S, A> actual = instance.run(initS);
+    P2<S, A> expected = p(initS, f.f(initS));
+    return actual.equals(expected);
+  }
+
+  public Property put() {
+    return property(
+        arbInteger,
+        arbInteger,
+        (newS, initS) -> prop(testPut(newS, initS)));
+  }
+
+  private static <S> boolean testPut(S newS, S initS) {
+    State<S, Unit> instance = State.put(newS);
+    P2<S, Unit> actual = instance.run(initS);
+    P2<S, Unit> expected = p(newS, Unit.unit());
+    return actual.equals(expected);
+  }
+
+  public Property modify() {
+    return property(
+        arbF(coarbInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testModify(f, initS)));
+  }
+
+  private static <S> boolean testModify(F<S, S> f, S initS) {
+    State<S, Unit> instance = State.modify(f);
+    P2<S, Unit> actual = instance.run(initS);
+    P2<S, Unit> expected = p(f.f(initS), Unit.unit());
+    return actual.equals(expected);
+  }
+
+  public Property staticFlatMap() {
+    return property(
+        arbRunF(coarbInteger, arbInteger, arbInteger),
+        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (runF, f, initS) -> prop(testStaticFlatMap(runF, f, initS)));
+  }
+
+  private static <S, A, B> boolean testStaticFlatMap(F<S, P2<S, A>> runF, F<A, State<S, B>> f, S initS) {
+    State<S, B> instance = State.flatMap(State.unit(runF), f);
+    P2<S, B> actual = instance.run(initS);
+    P2<S, A> intermediateExpected = runF.f(initS);
+    P2<S, B> expected = f.f(intermediateExpected._2()).run(intermediateExpected._1());
+    return actual.equals(expected);
+  }
+
+  public Property sequence() {
+    return property(
+        arbList(arbState(coarbInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (states, initS) -> prop(testSequence(states, initS)));
+  }
+
+  private static <S, A> boolean testSequence(List<State<S, A>> states, S initS) {
+    State<S, List<A>> instance = State.sequence(states);
+    P2<S, List<A>> actual = instance.run(initS);
+
+    S expectedFinalS = initS;
+    List<A> expectedAs = List.nil();
+    List<State<S, A>> remainingStates = states;
+    while (remainingStates.isNotEmpty()) {
+      P2<S, A> nextResult = remainingStates.head().run(expectedFinalS);
+      expectedFinalS = nextResult._1();
+      expectedAs = List.cons(nextResult._2(), expectedAs);
+      remainingStates = remainingStates.tail();
+    }
+    expectedAs = expectedAs.reverse();
+
+    P2<S, List<A>> expected = p(expectedFinalS, expectedAs);
+    return actual.equals(expected);
+  }
+
+  public Property traverse() {
+    return property(
+        arbList(arbInteger),
+        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (as, f, initS) -> prop(testTraverse(as, f, initS)));
+
+  }
+
+  private static <S, A, B> boolean testTraverse(List<A> as, F<A, State<S, B>> f, S initS) {
+    State<S, List<B>> instance = State.traverse(as, f);
+    P2<S, List<B>> actual = instance.run(initS);
+
+    S expectedFinalS = initS;
+    List<B> expectedFinalBs = List.nil();
+    List<A> currAs = as;
+    while (currAs.isNotEmpty()) {
+      P2<S, B> nextStateAndB = f.f(currAs.head()).run(expectedFinalS);
+      expectedFinalS = nextStateAndB._1();
+      expectedFinalBs = List.cons(nextStateAndB._2(), expectedFinalBs);
+      currAs = currAs.tail();
+    }
+    expectedFinalBs = expectedFinalBs.reverse();
+    P2<S, List<B>> expected = p(expectedFinalS, expectedFinalBs);
+
+    return actual.equals(expected);
+  }
+
+  public Property run() {
+    return property(
+        arbRunF(coarbInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testRun(runF, initS)));
+  }
+
+  private static <S, A> boolean testRun(F<S, P2<S, A>> runF, S initS) {
+    State<S, A> instance = State.unit(runF);
+    P2<S, A> actual = instance.run(initS);
+    P2<S, A> expected = runF.f(initS);
+    return actual.equals(expected);
+  }
+
+  public Property eval() {
+    return property(
+        arbRunF(coarbInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testEval(runF, initS)));
+  }
+
+  private static <S, A> boolean testEval(F<S, P2<S, A>> runF, S initS) {
+    State<S, A> instance = State.unit(runF);
+    A actual = instance.eval(initS);
+    A expected = runF.f(initS)._2();
+    return actual.equals(expected);
+  }
+
+  public Property exec() {
+    return property(
+        arbRunF(coarbInteger, arbInteger, arbUnit),
+        arbInteger,
+        (runF, initS) -> prop(testExec(runF, initS)));
+  }
+
+  private static <S> boolean testExec(F<S, P2<S, Unit>> runF, S initS) {
+    State<S, Unit> instance = State.unit(runF);
+    S actual = instance.exec(initS);
+    S expected = runF.f(initS)._1();
+    return actual.equals(expected);
+  }
+
+  public Property getsProperty() {
+    return property(
+        arbState(coarbInteger, arbInteger, arbInteger),
+        arbInteger,
+        (state, initS) -> prop(testGets(state, initS)));
+  }
+
+  private static <S, A> boolean testGets(State<S, A> state, S initS) {
+    State<S, S> instance = state.gets();
+    P2<S, S> actual = instance.run(initS);
+    P2<S, S> expected = p(state.run(initS)._1(), state.run(initS)._1());
+    return actual.equals(expected);
+  }
+
+  public Property map() {
+    return property(
+        arbState(coarbInteger, arbInteger, arbInteger),
+        arbF(coarbInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testMap(state, f, initS)));
+  }
+
+  private static <S, A, B> boolean testMap(State<S, A> state, F<A, B> f, S initS) {
+    State<S, B> instance = state.map(f);
+    P2<S, B> actual = instance.run(initS);
+    P2<S, B> expected = state.run(initS).map2(f);
+    return actual.equals(expected);
+  }
+
+  public Property mapState() {
+    return property(
+        arbState(coarbInteger, arbInteger, arbInteger),
+        arbMapStateF(coarbInteger, coarbInteger, arbInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testMapState(state, f, initS)));
+  }
+
+  private static <S, A, B> boolean testMapState(State<S, A> state, F<P2<S, A>, P2<S, B>> f, S initS) {
+    State<S, B> instance = state.mapState(f);
+    P2<S, B> actual = instance.run(initS);
+    P2<S, B> expected = f.f(state.run(initS));
+    return actual.equals(expected);
+  }
+
+  public Property withs() {
+    return property(
+        arbState(coarbInteger, arbInteger, arbInteger),
+        arbF(coarbInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testWiths(state, f, initS)));
+  }
+
+  private static <S, A> boolean testWiths(State<S, A> state, F<S, S> f, S initS) {
+    State<S, A> instance = state.withs(f);
+    P2<S, A> actual = instance.run(initS);
+    P2<S, A> expected = state.run(f.f(initS));
+    return actual.equals(expected);
+  }
+
+  public Property flatMap() {
+    return property(
+        arbState(coarbInteger, arbInteger, arbInteger),
+        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (state, f, initS) -> prop(testFlatMap(state, f, initS)));
+  }
+
+  private static <S, A, B> boolean testFlatMap(State<S, A> state, F<A, State<S, B>> f, S initS) {
+    State<S, B> instance = state.flatMap(f);
+    P2<S, B> actual = instance.run(initS);
+    P2<S, B> expected = f.f(state.run(initS)._2()).run(state.run(initS)._1());
+    return actual.equals(expected);
+  }
+
+  @CheckParams(minSuccessful = 1)
+  public Property getsStackSafety() {
+    return property(
+        arbHugeState(
+            arbState(coarbInteger, arbInteger, arbInteger),
+            currState -> arbitrary(Gen.value(currState.gets()))),
+        arbInteger,
+        (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
+  }
+
+  @CheckParams(minSuccessful = 1)
+  public Property mapStackSafety() {
+    return property(
+        arbHugeState(
+            arbState(coarbInteger, arbInteger, arbInteger),
+            currState -> arbitrary(Gen.gen(s -> r -> currState.map(arbF(coarbInteger, arbInteger).gen.gen(s, r))))),
+        arbInteger,
+        (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
+  }
+
+  @CheckParams(minSuccessful = 1)
+  public Property mapStateStackSafety() {
+    return property(
+        arbHugeState(
+            arbState(coarbInteger, arbInteger, arbInteger),
+            currState -> arbitrary(Gen.gen(s -> r ->
+                currState.mapState(arbMapStateF(coarbInteger, coarbInteger, arbInteger, arbInteger).gen.gen(s, r))))),
+        arbInteger,
+        (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
+  }
+
+  @CheckParams(minSuccessful = 1)
+  public Property withsStackSafety() {
+    return property(
+        arbHugeState(
+            arbState(coarbInteger, arbInteger, arbInteger),
+            currState -> arbitrary(Gen.gen(s -> r -> currState.withs(arbF(coarbInteger, arbInteger).gen.gen(s, r))))),
+        arbInteger,
+        (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
+  }
+
+  @CheckParams(minSuccessful = 1)
+  public Property flatMapStackSafety() {
+    return property(
+        arbHugeState(
+            arbState(coarbInteger, arbInteger, arbInteger),
+            currState -> arbitrary(Gen.gen(s -> r ->
+                currState.flatMap(arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)).gen.gen(s, r))))),
+        arbInteger,
+        (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
+  }
+
+  private static <S, A> boolean testNoStackOverflow(State<S, A> instance, S initS) {
+    instance.run(initS);
+    return true;
+  }
+
+  private static final Arbitrary<Unit> arbUnit = arbitrary(Gen.value(Unit.unit()));
+
+  private static <S, A> Arbitrary<F<S, P2<S, A>>> arbRunF(
+      Coarbitrary<S> coarbInitS,
+      Arbitrary<S> arbNextS,
+      Arbitrary<A> arbValue) {
+
+    return arbF(coarbInitS, arbP2(arbNextS, arbValue));
+  }
+
+  private static <S, A> Arbitrary<F<P2<S, A>, P2<S, A>>> arbMapStateF(
+      Coarbitrary<S> coarbInitS,
+      Coarbitrary<A> coarbInitValue,
+      Arbitrary<S> arbNextS,
+      Arbitrary<A> arbNextValue) {
+
+    return arbF(coarbP2(coarbInitS, coarbInitValue), arbP2(arbNextS, arbNextValue));
+  }
+
+  private static <S, A> Arbitrary<State<S, A>> arbState(
+      Coarbitrary<S> coarbInitS,
+      Arbitrary<S> arbNextS,
+      Arbitrary<A> arbValue) {
+
+    Arbitrary<F<S, P2<S, A>>> arbRunF = arbRunF(coarbInitS, arbNextS, arbValue);
+    return arbitrary(Gen.gen(s -> r -> State.unit(arbRunF.gen.gen(s, r))));
+  }
+
+  private static final int HUGE_SIZE = 10000;
+
+  private static <S, A> Arbitrary<State<S, A>> arbHugeState(
+      Arbitrary<State<S, A>> arbInitState,
+      F<State<S, A>, Arbitrary<State<S, A>>> nextArbStateF) {
+
+    return arbitrary(Gen.gen(s -> r -> range(0, HUGE_SIZE).foldLeft(
+        (acc, x) -> nextArbStateF.f(acc).gen.gen(s, r),
+        arbInitState.gen.gen(s, r))));
+  }
+
+}

From 2833a566c61cbeaf677d0519d823f7b7ab78b8bd Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 14 Jun 2016 21:58:34 +0200
Subject: [PATCH 087/336] Remove use of Arbitrary wrapper

---
 .../test/java/fj/data/StateProperties.java    | 381 +++++++++---------
 1 file changed, 189 insertions(+), 192 deletions(-)

diff --git a/props-core/src/test/java/fj/data/StateProperties.java b/props-core/src/test/java/fj/data/StateProperties.java
index 3fb0e2ba..c5ce2a2e 100644
--- a/props-core/src/test/java/fj/data/StateProperties.java
+++ b/props-core/src/test/java/fj/data/StateProperties.java
@@ -3,8 +3,7 @@
 import fj.F;
 import fj.P2;
 import fj.Unit;
-import fj.test.Arbitrary;
-import fj.test.Coarbitrary;
+import fj.test.Cogen;
 import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -17,21 +16,16 @@
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.Arbitrary.arbList;
 import static fj.test.Arbitrary.arbP2;
-import static fj.test.Arbitrary.arbitrary;
-import static fj.test.Coarbitrary.coarbInteger;
-import static fj.test.Coarbitrary.coarbP2;
+import static fj.test.Cogen.cogenInteger;
+import static fj.test.Cogen.cogenP2;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
 @RunWith(PropertyTestRunner.class)
 public final class StateProperties {
 
-  public Property unit() {
-    return property(
-        arbRunF(coarbInteger, arbInteger, arbInteger),
-        arbInteger,
-        (runF, initS) -> prop(testUnit(runF, initS)));
-  }
+  private static final Gen<Unit> arbUnit = Gen.value(Unit.unit());
+  private static final int HUGE_SIZE = 10000;
 
   private static <S, A> boolean testUnit(F<S, P2<S, A>> runF, S initS) {
     State<S, A> instance = State.unit(runF);
@@ -40,12 +34,6 @@ private static <S, A> boolean testUnit(F<S, P2<S, A>> runF, S initS) {
     return actual.equals(expected);
   }
 
-  public Property init() {
-    return property(
-        arbInteger,
-        initS -> prop(testInit(initS)));
-  }
-
   private static <S> boolean testInit(S initS) {
     State<S, S> instance = State.init();
     P2<S, S> actual = instance.run(initS);
@@ -53,13 +41,6 @@ private static <S> boolean testInit(S initS) {
     return actual.equals(expected);
   }
 
-  public Property units() {
-    return property(
-        arbF(coarbInteger, arbInteger),
-        arbInteger,
-        (f, initS) -> prop(testUnits(f, initS)));
-  }
-
   private static <S> boolean testUnits(F<S, S> f, S initS) {
     State<S, S> instance = State.units(f);
     P2<S, S> actual = instance.run(initS);
@@ -68,13 +49,6 @@ private static <S> boolean testUnits(F<S, S> f, S initS) {
     return actual.equals(expected);
   }
 
-  public Property constant() {
-    return property(
-        arbInteger,
-        arbInteger,
-        (a, initS) -> prop(testConstant(a, initS)));
-  }
-
   private static <S, A> boolean testConstant(A a, S initS) {
     State<S, A> instance = State.constant(a);
     P2<S, A> actual = instance.run(initS);
@@ -82,13 +56,6 @@ private static <S, A> boolean testConstant(A a, S initS) {
     return actual.equals(expected);
   }
 
-  public Property staticGets() {
-    return property(
-        arbF(coarbInteger, arbInteger),
-        arbInteger,
-        (f, initS) -> prop(testStaticGets(f, initS)));
-  }
-
   private static <S, A> boolean testStaticGets(F<S, A> f, S initS) {
     State<S, A> instance = State.gets(f);
     P2<S, A> actual = instance.run(initS);
@@ -96,13 +63,6 @@ private static <S, A> boolean testStaticGets(F<S, A> f, S initS) {
     return actual.equals(expected);
   }
 
-  public Property put() {
-    return property(
-        arbInteger,
-        arbInteger,
-        (newS, initS) -> prop(testPut(newS, initS)));
-  }
-
   private static <S> boolean testPut(S newS, S initS) {
     State<S, Unit> instance = State.put(newS);
     P2<S, Unit> actual = instance.run(initS);
@@ -110,13 +70,6 @@ private static <S> boolean testPut(S newS, S initS) {
     return actual.equals(expected);
   }
 
-  public Property modify() {
-    return property(
-        arbF(coarbInteger, arbInteger),
-        arbInteger,
-        (f, initS) -> prop(testModify(f, initS)));
-  }
-
   private static <S> boolean testModify(F<S, S> f, S initS) {
     State<S, Unit> instance = State.modify(f);
     P2<S, Unit> actual = instance.run(initS);
@@ -124,14 +77,6 @@ private static <S> boolean testModify(F<S, S> f, S initS) {
     return actual.equals(expected);
   }
 
-  public Property staticFlatMap() {
-    return property(
-        arbRunF(coarbInteger, arbInteger, arbInteger),
-        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
-        arbInteger,
-        (runF, f, initS) -> prop(testStaticFlatMap(runF, f, initS)));
-  }
-
   private static <S, A, B> boolean testStaticFlatMap(F<S, P2<S, A>> runF, F<A, State<S, B>> f, S initS) {
     State<S, B> instance = State.flatMap(State.unit(runF), f);
     P2<S, B> actual = instance.run(initS);
@@ -140,13 +85,6 @@ private static <S, A, B> boolean testStaticFlatMap(F<S, P2<S, A>> runF, F<A, Sta
     return actual.equals(expected);
   }
 
-  public Property sequence() {
-    return property(
-        arbList(arbState(coarbInteger, arbInteger, arbInteger)),
-        arbInteger,
-        (states, initS) -> prop(testSequence(states, initS)));
-  }
-
   private static <S, A> boolean testSequence(List<State<S, A>> states, S initS) {
     State<S, List<A>> instance = State.sequence(states);
     P2<S, List<A>> actual = instance.run(initS);
@@ -166,15 +104,6 @@ private static <S, A> boolean testSequence(List<State<S, A>> states, S initS) {
     return actual.equals(expected);
   }
 
-  public Property traverse() {
-    return property(
-        arbList(arbInteger),
-        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
-        arbInteger,
-        (as, f, initS) -> prop(testTraverse(as, f, initS)));
-
-  }
-
   private static <S, A, B> boolean testTraverse(List<A> as, F<A, State<S, B>> f, S initS) {
     State<S, List<B>> instance = State.traverse(as, f);
     P2<S, List<B>> actual = instance.run(initS);
@@ -194,13 +123,6 @@ private static <S, A, B> boolean testTraverse(List<A> as, F<A, State<S, B>> f, S
     return actual.equals(expected);
   }
 
-  public Property run() {
-    return property(
-        arbRunF(coarbInteger, arbInteger, arbInteger),
-        arbInteger,
-        (runF, initS) -> prop(testRun(runF, initS)));
-  }
-
   private static <S, A> boolean testRun(F<S, P2<S, A>> runF, S initS) {
     State<S, A> instance = State.unit(runF);
     P2<S, A> actual = instance.run(initS);
@@ -208,13 +130,6 @@ private static <S, A> boolean testRun(F<S, P2<S, A>> runF, S initS) {
     return actual.equals(expected);
   }
 
-  public Property eval() {
-    return property(
-        arbRunF(coarbInteger, arbInteger, arbInteger),
-        arbInteger,
-        (runF, initS) -> prop(testEval(runF, initS)));
-  }
-
   private static <S, A> boolean testEval(F<S, P2<S, A>> runF, S initS) {
     State<S, A> instance = State.unit(runF);
     A actual = instance.eval(initS);
@@ -222,13 +137,6 @@ private static <S, A> boolean testEval(F<S, P2<S, A>> runF, S initS) {
     return actual.equals(expected);
   }
 
-  public Property exec() {
-    return property(
-        arbRunF(coarbInteger, arbInteger, arbUnit),
-        arbInteger,
-        (runF, initS) -> prop(testExec(runF, initS)));
-  }
-
   private static <S> boolean testExec(F<S, P2<S, Unit>> runF, S initS) {
     State<S, Unit> instance = State.unit(runF);
     S actual = instance.exec(initS);
@@ -236,13 +144,6 @@ private static <S> boolean testExec(F<S, P2<S, Unit>> runF, S initS) {
     return actual.equals(expected);
   }
 
-  public Property getsProperty() {
-    return property(
-        arbState(coarbInteger, arbInteger, arbInteger),
-        arbInteger,
-        (state, initS) -> prop(testGets(state, initS)));
-  }
-
   private static <S, A> boolean testGets(State<S, A> state, S initS) {
     State<S, S> instance = state.gets();
     P2<S, S> actual = instance.run(initS);
@@ -250,14 +151,6 @@ private static <S, A> boolean testGets(State<S, A> state, S initS) {
     return actual.equals(expected);
   }
 
-  public Property map() {
-    return property(
-        arbState(coarbInteger, arbInteger, arbInteger),
-        arbF(coarbInteger, arbInteger),
-        arbInteger,
-        (state, f, initS) -> prop(testMap(state, f, initS)));
-  }
-
   private static <S, A, B> boolean testMap(State<S, A> state, F<A, B> f, S initS) {
     State<S, B> instance = state.map(f);
     P2<S, B> actual = instance.run(initS);
@@ -265,14 +158,6 @@ private static <S, A, B> boolean testMap(State<S, A> state, F<A, B> f, S initS)
     return actual.equals(expected);
   }
 
-  public Property mapState() {
-    return property(
-        arbState(coarbInteger, arbInteger, arbInteger),
-        arbMapStateF(coarbInteger, coarbInteger, arbInteger, arbInteger),
-        arbInteger,
-        (state, f, initS) -> prop(testMapState(state, f, initS)));
-  }
-
   private static <S, A, B> boolean testMapState(State<S, A> state, F<P2<S, A>, P2<S, B>> f, S initS) {
     State<S, B> instance = state.mapState(f);
     P2<S, B> actual = instance.run(initS);
@@ -280,14 +165,6 @@ private static <S, A, B> boolean testMapState(State<S, A> state, F<P2<S, A>, P2<
     return actual.equals(expected);
   }
 
-  public Property withs() {
-    return property(
-        arbState(coarbInteger, arbInteger, arbInteger),
-        arbF(coarbInteger, arbInteger),
-        arbInteger,
-        (state, f, initS) -> prop(testWiths(state, f, initS)));
-  }
-
   private static <S, A> boolean testWiths(State<S, A> state, F<S, S> f, S initS) {
     State<S, A> instance = state.withs(f);
     P2<S, A> actual = instance.run(initS);
@@ -295,14 +172,6 @@ private static <S, A> boolean testWiths(State<S, A> state, F<S, S> f, S initS) {
     return actual.equals(expected);
   }
 
-  public Property flatMap() {
-    return property(
-        arbState(coarbInteger, arbInteger, arbInteger),
-        arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)),
-        arbInteger,
-        (state, f, initS) -> prop(testFlatMap(state, f, initS)));
-  }
-
   private static <S, A, B> boolean testFlatMap(State<S, A> state, F<A, State<S, B>> f, S initS) {
     State<S, B> instance = state.flatMap(f);
     P2<S, B> actual = instance.run(initS);
@@ -310,12 +179,184 @@ private static <S, A, B> boolean testFlatMap(State<S, A> state, F<A, State<S, B>
     return actual.equals(expected);
   }
 
+  private static <S, A> boolean testNoStackOverflow(State<S, A> instance, S initS) {
+    instance.run(initS);
+    return true;
+  }
+
+  private static <S, A> Gen<F<S, P2<S, A>>> arbRunF(
+      Cogen<S> cogenInitS,
+      Gen<S> arbNextS,
+      Gen<A> arbValue) {
+
+    return arbF(cogenInitS, arbP2(arbNextS, arbValue));
+  }
+
+  private static <S, A> Gen<F<P2<S, A>, P2<S, A>>> arbMapStateF(
+      Cogen<S> cogenInitS,
+      Cogen<A> cogenInitValue,
+      Gen<S> arbNextS,
+      Gen<A> arbNextValue) {
+
+    return arbF(cogenP2(cogenInitS, cogenInitValue), arbP2(arbNextS, arbNextValue));
+  }
+
+  private static <S, A> Gen<State<S, A>> arbState(
+      Cogen<S> cogenInitS,
+      Gen<S> arbNextS,
+      Gen<A> arbValue) {
+
+    Gen<F<S, P2<S, A>>> arbRunF = arbRunF(cogenInitS, arbNextS, arbValue);
+    return Gen.gen(s -> r -> State.unit(arbRunF.gen(s, r)));
+  }
+
+  private static <S, A> Gen<State<S, A>> arbHugeState(
+      Gen<State<S, A>> arbInitState,
+      F<State<S, A>, Gen<State<S, A>>> nextArbStateF) {
+
+    return Gen.gen(s -> r -> range(0, HUGE_SIZE).foldLeft(
+        (acc, x) -> nextArbStateF.f(acc).gen(s, r),
+        arbInitState.gen(s, r)));
+  }
+
+  public Property unit() {
+    return property(
+        arbRunF(cogenInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testUnit(runF, initS)));
+  }
+
+  public Property init() {
+    return property(
+        arbInteger,
+        initS -> prop(testInit(initS)));
+  }
+
+  public Property units() {
+    return property(
+        arbF(cogenInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testUnits(f, initS)));
+  }
+
+  public Property constant() {
+    return property(
+        arbInteger,
+        arbInteger,
+        (a, initS) -> prop(testConstant(a, initS)));
+  }
+
+  public Property staticGets() {
+    return property(
+        arbF(cogenInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testStaticGets(f, initS)));
+  }
+
+  public Property put() {
+    return property(
+        arbInteger,
+        arbInteger,
+        (newS, initS) -> prop(testPut(newS, initS)));
+  }
+
+  public Property modify() {
+    return property(
+        arbF(cogenInteger, arbInteger),
+        arbInteger,
+        (f, initS) -> prop(testModify(f, initS)));
+  }
+
+  public Property staticFlatMap() {
+    return property(
+        arbRunF(cogenInteger, arbInteger, arbInteger),
+        arbF(cogenInteger, arbState(cogenInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (runF, f, initS) -> prop(testStaticFlatMap(runF, f, initS)));
+  }
+
+  public Property sequence() {
+    return property(
+        arbList(arbState(cogenInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (states, initS) -> prop(testSequence(states, initS)));
+  }
+
+  public Property traverse() {
+    return property(
+        arbList(arbInteger),
+        arbF(cogenInteger, arbState(cogenInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (as, f, initS) -> prop(testTraverse(as, f, initS)));
+
+  }
+
+  public Property run() {
+    return property(
+        arbRunF(cogenInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testRun(runF, initS)));
+  }
+
+  public Property eval() {
+    return property(
+        arbRunF(cogenInteger, arbInteger, arbInteger),
+        arbInteger,
+        (runF, initS) -> prop(testEval(runF, initS)));
+  }
+
+  public Property exec() {
+    return property(
+        arbRunF(cogenInteger, arbInteger, arbUnit),
+        arbInteger,
+        (runF, initS) -> prop(testExec(runF, initS)));
+  }
+
+  public Property getsProperty() {
+    return property(
+        arbState(cogenInteger, arbInteger, arbInteger),
+        arbInteger,
+        (state, initS) -> prop(testGets(state, initS)));
+  }
+
+  public Property map() {
+    return property(
+        arbState(cogenInteger, arbInteger, arbInteger),
+        arbF(cogenInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testMap(state, f, initS)));
+  }
+
+  public Property mapState() {
+    return property(
+        arbState(cogenInteger, arbInteger, arbInteger),
+        arbMapStateF(cogenInteger, cogenInteger, arbInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testMapState(state, f, initS)));
+  }
+
+  public Property withs() {
+    return property(
+        arbState(cogenInteger, arbInteger, arbInteger),
+        arbF(cogenInteger, arbInteger),
+        arbInteger,
+        (state, f, initS) -> prop(testWiths(state, f, initS)));
+  }
+
+  public Property flatMap() {
+    return property(
+        arbState(cogenInteger, arbInteger, arbInteger),
+        arbF(cogenInteger, arbState(cogenInteger, arbInteger, arbInteger)),
+        arbInteger,
+        (state, f, initS) -> prop(testFlatMap(state, f, initS)));
+  }
+
   @CheckParams(minSuccessful = 1)
   public Property getsStackSafety() {
     return property(
         arbHugeState(
-            arbState(coarbInteger, arbInteger, arbInteger),
-            currState -> arbitrary(Gen.value(currState.gets()))),
+            arbState(cogenInteger, arbInteger, arbInteger),
+            currState -> Gen.value(currState.gets())),
         arbInteger,
         (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
   }
@@ -324,8 +365,8 @@ public Property getsStackSafety() {
   public Property mapStackSafety() {
     return property(
         arbHugeState(
-            arbState(coarbInteger, arbInteger, arbInteger),
-            currState -> arbitrary(Gen.gen(s -> r -> currState.map(arbF(coarbInteger, arbInteger).gen.gen(s, r))))),
+            arbState(cogenInteger, arbInteger, arbInteger),
+            currState -> Gen.gen(s -> r -> currState.map(arbF(cogenInteger, arbInteger).gen(s, r)))),
         arbInteger,
         (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
   }
@@ -334,9 +375,9 @@ public Property mapStackSafety() {
   public Property mapStateStackSafety() {
     return property(
         arbHugeState(
-            arbState(coarbInteger, arbInteger, arbInteger),
-            currState -> arbitrary(Gen.gen(s -> r ->
-                currState.mapState(arbMapStateF(coarbInteger, coarbInteger, arbInteger, arbInteger).gen.gen(s, r))))),
+            arbState(cogenInteger, arbInteger, arbInteger),
+            currState -> Gen.gen(s -> r ->
+                currState.mapState(arbMapStateF(cogenInteger, cogenInteger, arbInteger, arbInteger).gen(s, r)))),
         arbInteger,
         (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
   }
@@ -345,8 +386,8 @@ public Property mapStateStackSafety() {
   public Property withsStackSafety() {
     return property(
         arbHugeState(
-            arbState(coarbInteger, arbInteger, arbInteger),
-            currState -> arbitrary(Gen.gen(s -> r -> currState.withs(arbF(coarbInteger, arbInteger).gen.gen(s, r))))),
+            arbState(cogenInteger, arbInteger, arbInteger),
+            currState -> Gen.gen(s -> r -> currState.withs(arbF(cogenInteger, arbInteger).gen(s, r)))),
         arbInteger,
         (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
   }
@@ -355,55 +396,11 @@ public Property withsStackSafety() {
   public Property flatMapStackSafety() {
     return property(
         arbHugeState(
-            arbState(coarbInteger, arbInteger, arbInteger),
-            currState -> arbitrary(Gen.gen(s -> r ->
-                currState.flatMap(arbF(coarbInteger, arbState(coarbInteger, arbInteger, arbInteger)).gen.gen(s, r))))),
+            arbState(cogenInteger, arbInteger, arbInteger),
+            currState -> Gen.gen(s -> r ->
+                currState.flatMap(arbF(cogenInteger, arbState(cogenInteger, arbInteger, arbInteger)).gen(s, r)))),
         arbInteger,
         (instance, initS) -> prop(testNoStackOverflow(instance, initS)));
   }
 
-  private static <S, A> boolean testNoStackOverflow(State<S, A> instance, S initS) {
-    instance.run(initS);
-    return true;
-  }
-
-  private static final Arbitrary<Unit> arbUnit = arbitrary(Gen.value(Unit.unit()));
-
-  private static <S, A> Arbitrary<F<S, P2<S, A>>> arbRunF(
-      Coarbitrary<S> coarbInitS,
-      Arbitrary<S> arbNextS,
-      Arbitrary<A> arbValue) {
-
-    return arbF(coarbInitS, arbP2(arbNextS, arbValue));
-  }
-
-  private static <S, A> Arbitrary<F<P2<S, A>, P2<S, A>>> arbMapStateF(
-      Coarbitrary<S> coarbInitS,
-      Coarbitrary<A> coarbInitValue,
-      Arbitrary<S> arbNextS,
-      Arbitrary<A> arbNextValue) {
-
-    return arbF(coarbP2(coarbInitS, coarbInitValue), arbP2(arbNextS, arbNextValue));
-  }
-
-  private static <S, A> Arbitrary<State<S, A>> arbState(
-      Coarbitrary<S> coarbInitS,
-      Arbitrary<S> arbNextS,
-      Arbitrary<A> arbValue) {
-
-    Arbitrary<F<S, P2<S, A>>> arbRunF = arbRunF(coarbInitS, arbNextS, arbValue);
-    return arbitrary(Gen.gen(s -> r -> State.unit(arbRunF.gen.gen(s, r))));
-  }
-
-  private static final int HUGE_SIZE = 10000;
-
-  private static <S, A> Arbitrary<State<S, A>> arbHugeState(
-      Arbitrary<State<S, A>> arbInitState,
-      F<State<S, A>, Arbitrary<State<S, A>>> nextArbStateF) {
-
-    return arbitrary(Gen.gen(s -> r -> range(0, HUGE_SIZE).foldLeft(
-        (acc, x) -> nextArbStateF.f(acc).gen.gen(s, r),
-        arbInitState.gen.gen(s, r))));
-  }
-
 }

From 09b6713407a2f3e2d1eb2c2ebd72c402a8797262 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Sun, 12 Jun 2016 17:30:17 -0500
Subject: [PATCH 088/336] Implemented Equal, Hash, Arbitrary, and Shrink for
 Natural as well as the equals, hashCode and toString methods on Natural. 
 Also fixed the subtract method on Natural as well as the Javadoc on the
 Natural Semigroup for addition.

---
 core/src/main/java/fj/Equal.java              |  5 ++++
 core/src/main/java/fj/Hash.java               |  6 +++++
 core/src/main/java/fj/Semigroup.java          |  2 +-
 core/src/main/java/fj/data/Natural.java       | 23 ++++++++++++++++++-
 .../src/main/java/fj/test/Arbitrary.java      | 15 +++++++++++-
 quickcheck/src/main/java/fj/test/Shrink.java  |  7 ++++++
 6 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 2282b04e..465959e9 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -149,6 +149,11 @@ public static <A> Equal<A> anyEqual() {
    */
   public static final Equal<Short> shortEqual = anyEqual();
 
+  /**
+   * An equal instance for the <code>Natural</code> type.
+   */
+  public static final Equal<Natural> naturalEqual = bigintEqual.contramap(Natural::bigIntegerValue);
+
   /**
    * An equal instance for the {@link String} type.
    */
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 3e6c0ae8..14f8a9d7 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -115,6 +115,11 @@ public static <A> Hash<A> anyHash() {
    */
   public static final Hash<BigDecimal> bigdecimalHash = anyHash();
 
+  /**
+   * A hash instance for the {@link Natural} type.
+   */
+  public static final Hash<Natural> naturalHash = bigintHash.contramap(Natural::bigIntegerValue);
+
   /**
    * A hash instance for the <code>String</code> type.
    */
@@ -535,4 +540,5 @@ public static <A> Hash<V7<A>> v7Hash(final Hash<A> ea) {
   public static <A> Hash<V8<A>> v8Hash(final Hash<A> ea) {
     return streamHash(ea).contramap(V8.toStream_());
   }
+
 }
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 1427f0e5..7c5538f2 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -219,7 +219,7 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
       semigroup(Natural::multiply);
 
   /**
-   * A semigroup that multiplies natural numbers.
+   * A semigroup that adds natural numbers.
    */
   public static final Semigroup<Natural> naturalAdditionSemigroup =
       semigroup(Natural::add);
diff --git a/core/src/main/java/fj/data/Natural.java b/core/src/main/java/fj/data/Natural.java
index 23080a49..e52f77ca 100644
--- a/core/src/main/java/fj/data/Natural.java
+++ b/core/src/main/java/fj/data/Natural.java
@@ -1,11 +1,16 @@
 package fj.data;
 
 import static fj.Bottom.error;
+
+import fj.Equal;
 import fj.F;
 
 import static fj.Monoid.naturalAdditionMonoid;
 import static fj.Monoid.naturalMultiplicationMonoid;
 import static fj.Function.curry;
+
+import fj.Hash;
+import fj.Show;
 import fj.data.vector.V2;
 import fj.data.vector.V;
 
@@ -121,7 +126,7 @@ public Natural add(final Natural n) {
    * @return The difference between the two numbers, if this number is larger than the given one. Otherwise none.
    */
   public Option<Natural> subtract(final Natural n) {
-    return natural(n.value.subtract(value));
+    return natural(value.subtract(n.value));
   }
 
   /**
@@ -286,4 +291,20 @@ public static Natural sum(final List<Natural> ns) {
   public static Natural product(final List<Natural> ns) {
     return naturalMultiplicationMonoid.sumLeft(ns);
   }
+
+
+  @Override
+  public int hashCode() {
+    return Hash.naturalHash.hash(this);
+  }
+
+  @Override
+  public boolean equals(final Object that) {
+    return Equal.equals0(Natural.class, this, that, Equal.naturalEqual);
+  }
+
+  @Override
+  public String toString() {
+    return Show.naturalShow.showS(this);
+  }
 }
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index d8f88bed..ad671018 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -1,6 +1,8 @@
 package fj.test;
 
+import fj.Equal;
 import fj.F;
+import fj.F1Functions;
 import fj.F2;
 import fj.F3;
 import fj.F4;
@@ -11,6 +13,7 @@
 import fj.Function;
 import fj.Bottom;
 
+import static fj.Equal.longEqual;
 import static fj.Function.compose;
 import static fj.P.p;
 
@@ -37,9 +40,12 @@
 import fj.data.List;
 import fj.data.Set;
 import fj.data.TreeMap;
+import fj.function.Booleans;
 import fj.function.Effect1;
+import fj.function.Longs;
 
 import static fj.data.Stream.range;
+import static fj.function.Booleans.not;
 import static fj.test.Gen.choose;
 import static fj.test.Gen.elements;
 import static fj.test.Gen.fail;
@@ -469,6 +475,12 @@ public Gen<Short> f(final Integer i) {
     }
   });
 
+  /**
+   * An arbitrary implementation for naturals.
+   */
+  public static final Gen<Natural> arbNatural = arbLong.filter(not(longEqual.eq(Long.MIN_VALUE)))
+      .map(Longs.abs).map(Natural::natural).map(o -> o.some());
+
   /**
    * An arbitrary implementation for character values.
    */
@@ -760,7 +772,7 @@ public static <A> Gen<ArrayList<A>> arbArrayList(final Gen<A> aa) {
   /**
    * Returns an arbitrary implementation for a Java enumeration.
    *
-   * @param clazz The type of enum to return an arbtrary of.
+   * @param clazz The type of enum to return an arbitrary of.
    * @return An arbitrary for instances of the supplied enum type.
    */
   public static <A extends Enum<A>> Gen<A> arbEnumValue(final Class<A> clazz) {
@@ -1337,4 +1349,5 @@ public static <A, B, C, D, E> Gen<P5<A, B, C, D, E>> arbP5(final Gen<A> aa, fina
     return aa.bind(ab, ac, ad, ae, af, ag, ah,
         a -> b -> c -> d -> e -> f -> g -> h -> p(a, b, c, d, e, f, g, h));
   }
+
 }
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 2a2f0061..04fa6184 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -30,6 +30,7 @@
 import fj.data.Either;
 import fj.data.Java;
 import fj.data.List;
+import fj.data.Natural;
 import fj.data.Option;
 import fj.data.Stream;
 
@@ -181,6 +182,11 @@ public static <A> Shrink<A> empty() {
    */
   public static final Shrink<Double> shrinkDouble = shrinkLong.map(Long_Double, Double_Long);
 
+  /**
+   * A shrink strategy for naturals.
+   */
+  public static final Shrink<Natural> shrinkNatural = shrinkLong.map(l -> Natural.natural(l).orSome(Natural.ZERO), Natural::longValue);
+
   /**
    * Returns a shrink strategy for optional values. A 'no value' is already fully
    * shrunk, otherwise, the shrinking occurs on the value with the given shrink strategy.
@@ -846,4 +852,5 @@ public static <A, B, C, D, E> Shrink<P5<A, B, C, D, E>> shrinkP5(final Shrink<A>
                           sg.shrink(p._7()), sh.shrink(p._8()), p8);
             });
   }
+
 }

From 9e5b6ad23fa0ef0d9f1784396bfd86758f6b9215 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Wed, 15 Jun 2016 22:02:52 +0200
Subject: [PATCH 089/336] Remove unnecessary indirection in Equal#eq partial
 application.

---
 core/src/main/java/fj/Equal.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 465959e9..a09dceba 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -65,7 +65,7 @@ public F2<A, A, Boolean> eq() {
    * @return A function that returns <code>true</code> if the given argument equals the argument to this method.
    */
   public F<A, Boolean> eq(final A a) {
-    return a1 -> eq(a, a1);
+    return f.f(a);
   }
 
   /**

From 03308243564d722e665de1d2f80fbfcbf449f891 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Wed, 15 Jun 2016 21:38:09 -0500
Subject: [PATCH 090/336] Fixed issue #276 by modifying the BigInteger Shrink
 implementation to use the same logic as the Shrink implementation for Long. 
 Also fixed some Javadoc typos.

---
 quickcheck/src/main/java/fj/test/Shrink.java | 47 ++++++++++----------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 04fa6184..7990401e 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -39,6 +39,8 @@
 import static fj.data.Stream.nil;
 
 import static java.lang.System.arraycopy;
+import static java.math.BigInteger.ZERO;
+
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.sql.Time;
@@ -354,7 +356,7 @@ public static <A> Shrink<ArrayList<A>> shrinkArrayList(final Shrink<A> sa) {
    * A shrink strategy for enum maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for enum maps.
    */
   public static <K extends Enum<K>, V> Shrink<EnumMap<K, V>> shrinkEnumMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -385,7 +387,7 @@ public static <A extends Enum<A>> Shrink<EnumSet<A>> shrinkEnumSet(final Shrink<
    * A shrink strategy for hash maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for hash maps.
    */
   public static <K, V> Shrink<HashMap<K, V>> shrinkHashMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -406,7 +408,7 @@ public static <A> Shrink<HashSet<A>> shrinkHashSet(final Shrink<A> sa) {
    * A shrink strategy for hash tables.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for hash tables.
    */
   @SuppressWarnings("UseOfObsoleteCollectionType")
@@ -430,7 +432,7 @@ public static <K, V> Shrink<Hashtable<K, V>> shrinkHashtable(final Shrink<K> sk,
    * A shrink strategy for identity hash maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for identity hash maps.
    */
   public static <K, V> Shrink<IdentityHashMap<K, V>> shrinkIdentityHashMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -441,7 +443,7 @@ public static <K, V> Shrink<IdentityHashMap<K, V>> shrinkIdentityHashMap(final S
    * A shrink strategy for linked hash maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for linked hash maps.
    */
   public static <K, V> Shrink<LinkedHashMap<K, V>> shrinkLinkedHashMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -514,7 +516,7 @@ public static <A> Shrink<Stack<A>> shrinkStack(final Shrink<A> sa) {
    * A shrink strategy for tree maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for tree maps.
    */
   public static <K, V> Shrink<TreeMap<K, V>> shrinkTreeMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -545,7 +547,7 @@ public static <A> Shrink<Vector<A>> shrinkVector(final Shrink<A> sa) {
    * A shrink strategy for weak hash maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for weak hash maps.
    */
   public static <K, V> Shrink<WeakHashMap<K, V>> shrinkWeakHashMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -570,7 +572,7 @@ public static <A> Shrink<ArrayBlockingQueue<A>> shrinkArrayBlockingQueue(final S
    * A shrink strategy for concurrent hash maps.
    *
    * @param sk The shrink strategy for keys.
-   * @param sv The shrink stratgey for values.
+   * @param sv The shrink strategy for values.
    * @return A shrink strategy for concurrent hash maps.
    */
   public static <K, V> Shrink<ConcurrentHashMap<K, V>> shrinkConcurrentHashMap(final Shrink<K> sk, final Shrink<V> sv) {
@@ -676,23 +678,20 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
   /**
    * A shrink strategy for big integers.
    */
-  public static final Shrink<BigInteger> shrinkBigInteger =
-      shrinkP2(shrinkByte, shrinkArray(shrinkByte)).map(bs -> {
-        final byte[] x = new byte[bs._2().length() + 1];
-
-        for (int i = 0; i < bs._2().array().length; i++) {
-          x[i] = bs._2().get(i);
-        }
-
-        x[bs._2().length()] = bs._1();
+  public static final Shrink<BigInteger> shrinkBigInteger = shrink(i -> {
+    final Equal<BigInteger> eq = Equal.bigintEqual;
+    final BigInteger two = BigInteger.valueOf(2L);
+    if (eq.eq(i, ZERO)) {
+      return nil();
+    } else {
+      final Stream<BigInteger> is = cons(ZERO,
+              () -> iterate(x -> x.divide(two), i)
+                      .takeWhile(x2 -> eq.notEq(x2, ZERO))
+                      .map(i::subtract));
 
-        return new BigInteger(x);
-      }, i -> {
-        final byte[] b = i.toByteArray();
-        final Byte[] x = new Byte[b.length - 1];
-        arraycopy(b, 0, x, 0, b.length - 1);
-        return p(b[0], array(x));
-      });
+      return Ord.bigintOrd.isLessThan(i, ZERO) ? cons(i.negate(), () -> is) : is;
+    }
+  });
 
   /**
    * A shrink strategy for big decimals.

From 56508b6f8ddea5f0e233b9732557ab846688ac6b Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Wed, 15 Jun 2016 23:14:12 -0500
Subject: [PATCH 091/336] Switched the the Gen and Shrink implementations for
 Natural to use BigInteger instead of Long. This will allow for generation of
 Naturals that are larger than Long.MAX_VALUE.  The implementations had to be
 moved within their respective classes to avoid forward reference compilation
 errors.

---
 quickcheck/src/main/java/fj/test/Arbitrary.java | 11 +++++------
 quickcheck/src/main/java/fj/test/Shrink.java    | 10 ++++++----
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index ad671018..d7a62523 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -475,12 +475,6 @@ public Gen<Short> f(final Integer i) {
     }
   });
 
-  /**
-   * An arbitrary implementation for naturals.
-   */
-  public static final Gen<Natural> arbNatural = arbLong.filter(not(longEqual.eq(Long.MIN_VALUE)))
-      .map(Longs.abs).map(Natural::natural).map(o -> o.some());
-
   /**
    * An arbitrary implementation for character values.
    */
@@ -1179,6 +1173,11 @@ public static <A> Gen<SynchronousQueue<A>> arbSynchronousQueue(final Gen<A> aa)
 
   // END java.math
 
+  /**
+   * An arbitrary implementation for naturals.
+   */
+  public static final Gen<Natural> arbNatural = arbBigInteger.map(BigInteger::abs).map(Natural::natural).map(o -> o.some());
+
   /**
    * An arbitrary implementation for locales.
    */
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 7990401e..77c95381 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -184,10 +184,6 @@ public static <A> Shrink<A> empty() {
    */
   public static final Shrink<Double> shrinkDouble = shrinkLong.map(Long_Double, Double_Long);
 
-  /**
-   * A shrink strategy for naturals.
-   */
-  public static final Shrink<Natural> shrinkNatural = shrinkLong.map(l -> Natural.natural(l).orSome(Natural.ZERO), Natural::longValue);
 
   /**
    * Returns a shrink strategy for optional values. A 'no value' is already fully
@@ -701,6 +697,12 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
 
   // END java.math
 
+  /**
+   * A shrink strategy for naturals.
+   */
+  public static final Shrink<Natural> shrinkNatural = shrinkBigInteger.map(l -> Natural.natural(l).orSome(Natural.ZERO), Natural::bigIntegerValue);
+
+
   /**
    * Returns a shrinking strategy for product-1 values.
    *

From 6bd372ba515463051167ddc09f66f9c7641dc53c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 15:28:24 +1000
Subject: [PATCH 092/336] Added functional to PriorityQueue

---
 core/src/main/java/fj/data/PriorityQueue.java | 37 ++++++++++++++++++-
 1 file changed, 35 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 67abdb88..18292768 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -3,6 +3,7 @@
 import fj.Equal;
 import fj.F;
 import fj.Monoid;
+import fj.Ord;
 import fj.P;
 import fj.P2;
 import fj.P3;
@@ -41,10 +42,14 @@ public <B> PriorityQueue<K, B> map(F<A, B> f) {
         );
     }
 
-    public PriorityQueue<K, A> filter(F<A, Boolean> f) {
+    public PriorityQueue<K, A> filterValues(F<A, Boolean> f) {
         return priorityQueue(equal, ftree.filter(p2 -> f.f(p2._2())));
     }
 
+    public PriorityQueue<K, A> filterKeys(F<K, Boolean> f) {
+        return priorityQueue(equal, ftree.filter(p2 -> f.f(p2._1())));
+    }
+
     public boolean isEmpty() {
         return ftree.isEmpty();
     }
@@ -63,6 +68,22 @@ public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
         return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);
     }
 
+    public boolean contains(final K k1) {
+        return !ftree.split(k2 -> equal.eq(k1, k2))._2().isEmpty();
+    }
+
+    public PriorityQueue<K, A> enqueue(Iterable<P2<K, A>> it) {
+        PriorityQueue<K, A> result = this;
+        for (P2<K, A> p: it) {
+            result = result.enqueue(p);
+        }
+        return result;
+    }
+
+    public PriorityQueue<K, A> enqueue(P2<K, A> p) {
+        return enqueue(p._1(), p._2());
+    }
+
     public PriorityQueue<K, A> dequeue() {
         K top = ftree.measure();
         P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(k, top));
@@ -70,6 +91,10 @@ public PriorityQueue<K, A> dequeue() {
         return right.isEmpty() ? this : priorityQueue(equal, p._1().append(right.tail()));
     }
 
+    public P2<Option<P2<K, A>>, PriorityQueue<K, A>> dequeueTop() {
+        return P.p(top(), dequeue());
+    }
+
     public PriorityQueue<K, A> dequeue(int n) {
         int i = n;
         PriorityQueue<K, A> result = this;
@@ -80,8 +105,16 @@ public PriorityQueue<K, A> dequeue(int n) {
         return result;
     }
 
+    public boolean isGreaterThan(Ord<K> ok, K k) {
+        return top().map(p -> ok.isGreaterThan(k, p._1())).orSome(true);
+    }
+
     public Stream<P2<K, A>> toStream() {
-        return ftree.toStream();
+        return top().map(p -> Stream.cons(p, () -> dequeue().toStream())).orSome(() -> Stream.nil());
+    }
+
+    public List<P2<K, A>> toList() {
+        return toStream().toList();
     }
 
     public String toString() {

From 2a2b8eac96f2d2660987634fcf87394c0756b92c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 15:30:56 +1000
Subject: [PATCH 093/336] Added priority queue properties

---
 .../test/java/fj/data/PriorityQueueTest.java  |  37 -------
 .../properties/PriorityQueueProperties.java   | 100 ++++++++++++++++++
 2 files changed, 100 insertions(+), 37 deletions(-)
 create mode 100644 props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java

diff --git a/core/src/test/java/fj/data/PriorityQueueTest.java b/core/src/test/java/fj/data/PriorityQueueTest.java
index 7e30cfc5..d7f532ed 100644
--- a/core/src/test/java/fj/data/PriorityQueueTest.java
+++ b/core/src/test/java/fj/data/PriorityQueueTest.java
@@ -14,42 +14,5 @@
  */
 public class PriorityQueueTest {
 
-    @Test
-    public void test1() {
-        PriorityQueue<Integer, Integer> pq = PriorityQueue.<Integer>emptyInt();
-        PriorityQueue<Integer, Integer> pq2 = pq.enqueue(List.list(p(1, 1)));
-        out.println(pq2.toString());
-    }
-
-    @Test
-    public void empty() {
-        PriorityQueue<Integer, Integer> pq = PriorityQueue.<Integer>emptyInt();
-        assertThat(pq.isEmpty(), is(true));
-    }
-
-    @Test
-    public void top() {
-        PriorityQueue<Integer, Integer> pq1 = PriorityQueue.emptyInt();
-        Option<P2<Integer, Integer>> o = pq1.top();
-        assertThat(o, is(Option.none()));
-    }
-
-    @Test
-    public void dequeue() {
-        PriorityQueue<Integer, Integer> pq1 = PriorityQueue.<Integer>emptyInt().enqueue(List.list(
-                p(3, 6), p(10, 20), p(4, 8), p(1, 2)
-        ));
-        out.println(pq1);
-        assertThat(pq1.toString(), equalTo("PriorityQueue((3: 6), (10: 20), (4: 8), (1: 2))"));
-
-        PriorityQueue<Integer, Integer> pq2 = PriorityQueue.emptyInt();
-        PriorityQueue<Integer, Integer> pq3 = pq2.dequeue();
-        out.println(pq3);
-        assertThat(pq3.toString(), equalTo("PriorityQueue()"));
-
-        PriorityQueue<Integer, Integer> pq4 = pq1.dequeue();
-        out.println(pq4);
-        assertThat(pq4.toString(), equalTo("PriorityQueue((3: 6), (4: 8), (1: 2))"));
-    }
 
 }
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
new file mode 100644
index 00000000..92b45264
--- /dev/null
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -0,0 +1,100 @@
+package fj.data.properties;
+
+import fj.Ord;
+import fj.P;
+import fj.P2;
+import fj.data.List;
+import fj.data.Option;
+import fj.data.PriorityQueue;
+import fj.data.Set;
+import fj.test.Arbitrary;
+import fj.test.Property;
+import fj.test.reflect.CheckParams;
+import fj.test.runner.PropertyTestRunner;
+import org.junit.runner.RunWith;
+
+import static fj.data.Option.some;
+import static fj.data.PriorityQueue.emptyInt;
+import static fj.test.Arbitrary.arbAlphaNumString;
+import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbSet;
+import static fj.test.Arbitrary.arbitrary;
+import static fj.test.Property.impliesBoolean;
+import static fj.test.Property.prop;
+import static fj.test.Property.property;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by MarkPerry on 18 Jun 16.
+ */
+@RunWith(PropertyTestRunner.class)
+@CheckParams(maxSize = 100)
+public class PriorityQueueProperties {
+
+    public static Arbitrary<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
+
+    public static <A> Arbitrary<PriorityQueue<Integer, A>> arbUniqueQueue(Arbitrary<A> aa) {
+        Arbitrary<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
+        Arbitrary<List<Integer>> ints = arbitrary(as.gen.map(si -> si.toList()));
+        Arbitrary<List<P2<Integer, A>>> alp = arbitrary(
+                ints.gen.bind(li -> aa.gen.map(s -> li.map(i -> P.p(i, s))))
+        );
+        return arbitrary(alp.gen.map(l -> PriorityQueue.<A>emptyInt().enqueue(l)));
+    }
+
+    Property empty() {
+        PriorityQueue<Integer, Object> pq = emptyInt();
+        return prop(pq.isEmpty());
+    }
+
+    Property addRemove() {
+        return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
+            Option<P2<Integer, String>> o = q.top();
+            Option<P2<Integer, String>> o2 = q.enqueue(i, s).dequeue().top();
+            return Property.impliesBoolean(
+                    q.isGreaterThan(Ord.intOrd, i),
+//                    o.map(p -> i > p._1()).orSome(true),
+                    () -> o.equals(o2)
+            );
+        });
+    }
+
+    Property emptyTop() {
+        return prop(emptyInt().top().isNone());
+    }
+
+    Property addTop() {
+        return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
+            Option<P2<Integer, String>> actual = q.enqueue(i, s).top();
+            return impliesBoolean(
+                    q.isGreaterThan(Ord.intOrd, i),
+//                    q.top().map(p -> p._1() < i).orSome(true),
+                    actual.equals(some(P.p(i, s))));
+        });
+    }
+
+    Property sorted() {
+        Arbitrary<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
+        Arbitrary<List<Integer>> ints = arbitrary(as.gen.map(si -> si.toList()));
+        Arbitrary<List<P2<Integer, String>>> alp = arbitrary(
+            ints.gen.bind(li -> arbAlphaNumString.gen.map(s -> li.map(i -> P.p(i, s))))
+        );
+        return property(alp, list -> {
+            PriorityQueue<Integer, String> q = PriorityQueue.<String>emptyInt().enqueue(list);
+            List<P2<Integer, String>> expected = list.sort(Ord.p2Ord1(Ord.intOrd.reverse()));
+            List<P2<Integer, String>> actual = q.toStream().toList();
+            assertThat(actual, equalTo(expected));
+            System.out.println(actual);
+            return prop(actual.equals(expected));
+        });
+    }
+
+    public Property sorted2() {
+        return property(arbPriorityQueueIntegerString, pq -> {
+            List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
+            return prop(expected.equals(pq.toList()));
+        });
+    }
+
+}

From 1a7f3e672cfeeaf6fc3de66fdeeecbf671fd973a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 15:31:24 +1000
Subject: [PATCH 094/336] Added finger tree toStream property?

---
 .../fj/data/fingertrees/FingerTreeProperties.java    | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
index a4265be6..b7ed83f5 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
@@ -1,5 +1,7 @@
 package fj.data.fingertrees;
 
+import fj.P2;
+import fj.data.Stream;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
 import fj.test.runner.PropertyTestRunner;
@@ -17,10 +19,18 @@
 @CheckParams(maxSize = 10000)
 public class FingerTreeProperties {
 
-    public Property size() {
+    Property size() {
         return property(arbList(arbInteger), list ->
             prop(list.foldLeft((acc, i) -> acc.snoc(i), FingerTree.<Integer>emptyIntAddition()).length() == list.length())
         );
     }
 
+    Property stream() {
+        return property(arbList(arbInteger), list -> {
+            Stream<Integer> s1 = list.foldLeft((acc, i) -> acc.snoc(i), FingerTree.<Integer>emptyIntAddition()).toStream();
+            Stream<Integer> s2 = list.toStream();
+            return prop(s1.equals(s2));
+    });
+    }
+
 }

From e0839e19d59d54cac5d2f02681c9a839d29c38e5 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 17:39:28 +1000
Subject: [PATCH 095/336] Merge in upstream changes to remove arbitrary wrapper

---
 .../properties/PriorityQueueProperties.java   | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index 92b45264..9f4be0da 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -8,6 +8,7 @@
 import fj.data.PriorityQueue;
 import fj.data.Set;
 import fj.test.Arbitrary;
+import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
 import fj.test.runner.PropertyTestRunner;
@@ -18,7 +19,6 @@
 import static fj.test.Arbitrary.arbAlphaNumString;
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.Arbitrary.arbSet;
-import static fj.test.Arbitrary.arbitrary;
 import static fj.test.Property.impliesBoolean;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
@@ -32,15 +32,15 @@
 @CheckParams(maxSize = 100)
 public class PriorityQueueProperties {
 
-    public static Arbitrary<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
+    public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
 
-    public static <A> Arbitrary<PriorityQueue<Integer, A>> arbUniqueQueue(Arbitrary<A> aa) {
-        Arbitrary<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
-        Arbitrary<List<Integer>> ints = arbitrary(as.gen.map(si -> si.toList()));
-        Arbitrary<List<P2<Integer, A>>> alp = arbitrary(
-                ints.gen.bind(li -> aa.gen.map(s -> li.map(i -> P.p(i, s))))
+    public static <A> Gen<PriorityQueue<Integer, A>> arbUniqueQueue(Gen<A> aa) {
+        Gen<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
+        Gen<List<Integer>> ints = (as.map(si -> si.toList()));
+        Gen<List<P2<Integer, A>>> alp = (
+                ints.bind(li -> aa.map(s -> li.map(i -> P.p(i, s))))
         );
-        return arbitrary(alp.gen.map(l -> PriorityQueue.<A>emptyInt().enqueue(l)));
+        return (alp.map(l -> PriorityQueue.<A>emptyInt().enqueue(l)));
     }
 
     Property empty() {
@@ -75,10 +75,10 @@ Property addTop() {
     }
 
     Property sorted() {
-        Arbitrary<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
-        Arbitrary<List<Integer>> ints = arbitrary(as.gen.map(si -> si.toList()));
-        Arbitrary<List<P2<Integer, String>>> alp = arbitrary(
-            ints.gen.bind(li -> arbAlphaNumString.gen.map(s -> li.map(i -> P.p(i, s))))
+        Gen<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
+        Gen<List<Integer>> ints = (as.map(si -> si.toList()));
+        Gen<List<P2<Integer, String>>> alp = (
+            ints.bind(li -> arbAlphaNumString.map(s -> li.map(i -> P.p(i, s))))
         );
         return property(alp, list -> {
             PriorityQueue<Integer, String> q = PriorityQueue.<String>emptyInt().enqueue(list);

From e3d8fce63b2587d3fae0a769c82b00b8311dfc7d Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 20:31:59 +1000
Subject: [PATCH 096/336] Added priority queue and related methods javadoc

---
 core/src/main/java/fj/Monoid.java             | 15 ++++-
 core/src/main/java/fj/data/PriorityQueue.java | 66 ++++++++++++++++++-
 .../java/fj/data/fingertrees/FingerTree.java  | 12 ++++
 .../test/java/fj/data/PriorityQueueTest.java  | 18 -----
 .../properties/PriorityQueueProperties.java   | 39 +++++------
 5 files changed, 107 insertions(+), 43 deletions(-)
 delete mode 100644 core/src/test/java/fj/data/PriorityQueueTest.java

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index d9bf40b5..3436d5a3 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -401,8 +401,14 @@ public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
     return monoid(Semigroup.ioSemigroup(ma.semigroup()), IOFunctions.unit(ma.zero()));
   }
 
+  /**
+   * A monoid for the maximum of two integers.
+   */
   public static final Monoid<Integer> intMaxMonoid = monoid(Semigroup.intMaximumSemigroup, Integer.MIN_VALUE);
 
+  /**
+   * A monoid for the minimum of two integers.
+   */
   public static final Monoid<Integer> intMinMonoid = monoid(Semigroup.intMinimumSemigroup, Integer.MAX_VALUE);
 
   /**
@@ -420,7 +426,14 @@ public static <A> Monoid<Set<A>> setMonoid(final Ord<A> o) {
     return monoid(Semigroup.setSemigroup(), Set.empty(o));
   }
 
-  public static <A> Monoid<A> ordMonoid(Ord<A> o, A zero) {
+
+  /**
+   * A monoid for the maximum of elements with ordering o.
+   *
+   * @param o An ordering of elements.
+   * @param zero The minimum element.
+   */
+  public static <A> Monoid<A> ordMaxMonoid(final Ord<A> o, final A zero) {
     return monoid(o.max, zero);
   }
 
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 18292768..51abcabf 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -11,6 +11,8 @@
 import fj.data.fingertrees.FingerTree;
 
 /**
+ * A priority queue implementation backed by a {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are annotated with type K, are combined using a monoid of K and both the key and value are stored in the leaf.  Priorities of the same value are returned FIFO (first in, first out).
+ *
  * Created by MarkPerry on 31 May 16.
  */
 public class PriorityQueue<K, A> {
@@ -23,18 +25,33 @@ private PriorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
         ftree = ft;
     }
 
+    /**
+     * Creates a priority queue from a finger tree.
+     */
     public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
         return new PriorityQueue<K, A>(e, ft);
     }
 
+    /**
+     * Creates an empty priority queue.
+     *
+     * @param m A monoid to combine node annotations.
+     * @param e A value to compare key equality.
+     */
     public static <K, A> PriorityQueue<K, A> empty(Monoid<K> m, Equal<K> e) {
         return priorityQueue(e, FingerTree.empty(m, (P2<K, A> p) -> p._1()));
     }
 
+    /**
+     * An empty priority queue with integer priorities.
+     */
     public static <A> PriorityQueue<Integer, A> emptyInt() {
         return priorityQueue(Equal.intEqual, FingerTree.empty(Monoid.intMaxMonoid, (P2<Integer, A> p) -> p._1()));
     }
 
+    /**
+     * Maps the values in each node with function f.
+     */
     public <B> PriorityQueue<K, B> map(F<A, B> f) {
         return priorityQueue(equal,
                 ftree.map(p2 -> p2.map2(a -> f.f(a)),
@@ -42,36 +59,60 @@ public <B> PriorityQueue<K, B> map(F<A, B> f) {
         );
     }
 
+    /**
+     * Filters nodes based on the value inside each node.
+     */
     public PriorityQueue<K, A> filterValues(F<A, Boolean> f) {
         return priorityQueue(equal, ftree.filter(p2 -> f.f(p2._2())));
     }
 
+    /**
+     * Filters the nodes based on the annotation of each node.
+     */
     public PriorityQueue<K, A> filterKeys(F<K, Boolean> f) {
         return priorityQueue(equal, ftree.filter(p2 -> f.f(p2._1())));
     }
 
+    /**
+     * Is the tree empty?
+     */
     public boolean isEmpty() {
         return ftree.isEmpty();
     }
 
+    /**
+     * If the tree is not empty, returns the node with highest priority otherwise returns nothing.
+     */
     public Option<P2<K, A>> top() {
         K top = ftree.measure();
         P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(top, k));
         return p._2().headOption();
     }
 
+    /**
+     * Adds a node with priority k and value a.  This operation take O(1).
+     */
     public PriorityQueue<K, A> enqueue(K k, A a) {
         return priorityQueue(equal, ftree.snoc(P.p(k, a)));
     }
 
+    /**
+     * Adds nodes using the list of products with priority k and value a.  This operation takes O(list.length()).
+     */
     public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
         return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);
     }
 
-    public boolean contains(final K k1) {
-        return !ftree.split(k2 -> equal.eq(k1, k2))._2().isEmpty();
+    /**
+     * Does the priority k exist already?
+     */
+    public boolean contains(final K k) {
+        return !ftree.split(k2 -> equal.eq(k, k2))._2().isEmpty();
     }
 
+    /**
+     * Adds nodes using the iterable of products with priority k and value a.
+     */
     public PriorityQueue<K, A> enqueue(Iterable<P2<K, A>> it) {
         PriorityQueue<K, A> result = this;
         for (P2<K, A> p: it) {
@@ -80,10 +121,16 @@ public PriorityQueue<K, A> enqueue(Iterable<P2<K, A>> it) {
         return result;
     }
 
+    /**
+     * Adds a node with priority k and value a.  This operation take O(1).
+     */
     public PriorityQueue<K, A> enqueue(P2<K, A> p) {
         return enqueue(p._1(), p._2());
     }
 
+    /**
+     * Removes the node with the highest priority.
+     */
     public PriorityQueue<K, A> dequeue() {
         K top = ftree.measure();
         P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(k, top));
@@ -91,10 +138,16 @@ public PriorityQueue<K, A> dequeue() {
         return right.isEmpty() ? this : priorityQueue(equal, p._1().append(right.tail()));
     }
 
+    /**
+     * Returns a tuple of the node with the highest priority and the rest of the priority queue.
+     */
     public P2<Option<P2<K, A>>, PriorityQueue<K, A>> dequeueTop() {
         return P.p(top(), dequeue());
     }
 
+    /**
+     * Removes the top n elements with the highest priority.
+     */
     public PriorityQueue<K, A> dequeue(int n) {
         int i = n;
         PriorityQueue<K, A> result = this;
@@ -105,14 +158,23 @@ public PriorityQueue<K, A> dequeue(int n) {
         return result;
     }
 
+    /**
+     * Does the priority k have greater priority than the top of the queue?
+     */
     public boolean isGreaterThan(Ord<K> ok, K k) {
         return top().map(p -> ok.isGreaterThan(k, p._1())).orSome(true);
     }
 
+    /**
+     * Returns a stream of products with priority k and value a.
+     */
     public Stream<P2<K, A>> toStream() {
         return top().map(p -> Stream.cons(p, () -> dequeue().toStream())).orSome(() -> Stream.nil());
     }
 
+    /**
+     * Returns a list of products with priority k and value a.
+     */
     public List<P2<K, A>> toList() {
         return toStream().toList();
     }
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index aa72f020..ee985611 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -231,10 +231,22 @@ public static <A> FingerTree<Integer, A> emptyIntAddition() {
       return empty(intAdditionMonoid, Function.constant(1));
     }
 
+  /**
+   * Creates an empty finger tree with elements of type A and node annotations
+   * of type V.
+   *
+   * @param m A monoid to combine node annotations
+   * @param f Function to convert node element to annotation.
+   * @return An empty finger tree.
+   */
   public static <V, A> FingerTree<V, A> empty(Monoid<V> m, F<A, V> f) {
     return FingerTree.mkTree(measured(m, f)).empty();
   }
 
+  /**
+   * Returns a finger tree which combines the integer node annotations with the
+   * maximum function.  A priority queue with integer priorities.
+   */
   public static <A> FingerTree<Integer, P2<Integer, A>> emptyIntMax() {
     return empty(intMaxMonoid, (P2<Integer, A> p) -> p._1());
   }
diff --git a/core/src/test/java/fj/data/PriorityQueueTest.java b/core/src/test/java/fj/data/PriorityQueueTest.java
deleted file mode 100644
index d7f532ed..00000000
--- a/core/src/test/java/fj/data/PriorityQueueTest.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package fj.data;
-
-import fj.P2;
-import org.junit.Test;
-
-import static fj.P.p;
-import static java.lang.System.out;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
-
-/**
- * Created by MarkPerry on 1 Jun 16.
- */
-public class PriorityQueueTest {
-
-
-}
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index 9f4be0da..aae27f67 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -7,7 +7,6 @@
 import fj.data.Option;
 import fj.data.PriorityQueue;
 import fj.data.Set;
-import fj.test.Arbitrary;
 import fj.test.Gen;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -22,8 +21,6 @@
 import static fj.test.Property.impliesBoolean;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
 
 /**
  * Created by MarkPerry on 18 Jun 16.
@@ -34,6 +31,9 @@ public class PriorityQueueProperties {
 
     public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
 
+    /**
+     * Returns a queue with unique integer priorities.
+     */
     public static <A> Gen<PriorityQueue<Integer, A>> arbUniqueQueue(Gen<A> aa) {
         Gen<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
         Gen<List<Integer>> ints = (as.map(si -> si.toList()));
@@ -48,49 +48,44 @@ Property empty() {
         return prop(pq.isEmpty());
     }
 
+    /**
+     * Adding a priority that is at the top and then removing it returns the original top.
+     */
     Property addRemove() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
             Option<P2<Integer, String>> o = q.top();
             Option<P2<Integer, String>> o2 = q.enqueue(i, s).dequeue().top();
             return Property.impliesBoolean(
                     q.isGreaterThan(Ord.intOrd, i),
-//                    o.map(p -> i > p._1()).orSome(true),
                     () -> o.equals(o2)
             );
         });
     }
 
+    /**
+     * An empty queue has no top.
+     */
     Property emptyTop() {
         return prop(emptyInt().top().isNone());
     }
 
+    /**
+     * Adding a value with the highest priority makes it the top item.
+     */
     Property addTop() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
             Option<P2<Integer, String>> actual = q.enqueue(i, s).top();
             return impliesBoolean(
                     q.isGreaterThan(Ord.intOrd, i),
-//                    q.top().map(p -> p._1() < i).orSome(true),
                     actual.equals(some(P.p(i, s))));
         });
     }
 
-    Property sorted() {
-        Gen<Set<Integer>> as = arbSet(Ord.intOrd, arbInteger);
-        Gen<List<Integer>> ints = (as.map(si -> si.toList()));
-        Gen<List<P2<Integer, String>>> alp = (
-            ints.bind(li -> arbAlphaNumString.map(s -> li.map(i -> P.p(i, s))))
-        );
-        return property(alp, list -> {
-            PriorityQueue<Integer, String> q = PriorityQueue.<String>emptyInt().enqueue(list);
-            List<P2<Integer, String>> expected = list.sort(Ord.p2Ord1(Ord.intOrd.reverse()));
-            List<P2<Integer, String>> actual = q.toStream().toList();
-            assertThat(actual, equalTo(expected));
-            System.out.println(actual);
-            return prop(actual.equals(expected));
-        });
-    }
-
-    public Property sorted2() {
+    /**
+     * Sorting a list returns the same as putting the list into a priority queue and getting
+     * the queue as a list.
+     */
+    public Property sorted() {
         return property(arbPriorityQueueIntegerString, pq -> {
             List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
             return prop(expected.equals(pq.toList()));

From c9788d4a21c90444e06914ca834e2aa6f51bc72c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 22:14:13 +1000
Subject: [PATCH 097/336] Make sorting a list stable

---
 core/src/main/java/fj/data/List.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 2b1a728e..d1f5ae63 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -962,7 +962,7 @@ List<A> merge(List<A> xs, List<A> ys, final Ord<A> o) {
             final A x = xs.head();
             final A y = ys.head();
 
-            if (o.isLessThan(x, y)) {
+            if (o.isLessThan(x, y) || o.eq(x, y)) {
               buf.snoc(x);
               xs = xs.tail();
             } else {

From 72d980f73cb053723a000fa0cae85accc1207075 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 22:15:35 +1000
Subject: [PATCH 098/336] Added priority queue top N, equal to top, greater
 than top

---
 core/src/main/java/fj/data/PriorityQueue.java | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 51abcabf..0559ca00 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -10,6 +10,8 @@
 import fj.Show;
 import fj.data.fingertrees.FingerTree;
 
+import static fj.data.List.list;
+
 /**
  * A priority queue implementation backed by a {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are annotated with type K, are combined using a monoid of K and both the key and value are stored in the leaf.  Priorities of the same value are returned FIFO (first in, first out).
  *
@@ -89,6 +91,16 @@ public Option<P2<K, A>> top() {
         return p._2().headOption();
     }
 
+    public List<P2<K, A>> topN() {
+        Stream<P2<K, A>> s = toStream();
+        if (s.isEmpty()) {
+            return List.nil();
+        } else {
+            final K k = s.head()._1();
+            return s.takeWhile(p -> equal.eq(k, p._1())).toList();
+        }
+    }
+
     /**
      * Adds a node with priority k and value a.  This operation take O(1).
      */
@@ -159,10 +171,18 @@ public PriorityQueue<K, A> dequeue(int n) {
     }
 
     /**
-     * Does the priority k have greater priority than the top of the queue?
+     * Does the top of the queue have lower priority than k?
      */
+    public boolean isLessThan(Ord<K> ok, K k) {
+        return top().map(p -> ok.isLessThan(p._1(), k)).orSome(true);
+    }
+
     public boolean isGreaterThan(Ord<K> ok, K k) {
-        return top().map(p -> ok.isGreaterThan(k, p._1())).orSome(true);
+        return top().map(p -> ok.isGreaterThan(p._1(), k)).orSome(false);
+    }
+
+    public boolean isEqual(Ord<K> ok, K k) {
+        return top().map(p -> ok.eq(p._1(), k)).orSome(false);
     }
 
     /**

From e5bc0e1bddb3df23966077bab0b6b67fcb1b41b2 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 22:16:11 +1000
Subject: [PATCH 099/336] FIFO priority queue properties where the key is equal
 to the top key

---
 .../properties/PriorityQueueProperties.java   | 48 ++++++++++++++-----
 1 file changed, 36 insertions(+), 12 deletions(-)

diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index aae27f67..ba387cad 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -17,10 +17,14 @@
 import static fj.data.PriorityQueue.emptyInt;
 import static fj.test.Arbitrary.arbAlphaNumString;
 import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbList;
+import static fj.test.Arbitrary.arbP2;
 import static fj.test.Arbitrary.arbSet;
 import static fj.test.Property.impliesBoolean;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
 
 /**
  * Created by MarkPerry on 18 Jun 16.
@@ -29,7 +33,7 @@
 @CheckParams(maxSize = 100)
 public class PriorityQueueProperties {
 
-    public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
+    public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbQueue(arbAlphaNumString);
 
     /**
      * Returns a queue with unique integer priorities.
@@ -43,6 +47,11 @@ public static <A> Gen<PriorityQueue<Integer, A>> arbUniqueQueue(Gen<A> aa) {
         return (alp.map(l -> PriorityQueue.<A>emptyInt().enqueue(l)));
     }
 
+    public static <A> Gen<PriorityQueue<Integer, A>> arbQueue(Gen<A> aa) {
+        Gen<List<P2<Integer, A>>> g = arbList(arbP2(arbInteger, aa));
+        return g.map(l -> PriorityQueue.<A>emptyInt().enqueue(l));
+    }
+
     Property empty() {
         PriorityQueue<Integer, Object> pq = emptyInt();
         return prop(pq.isEmpty());
@@ -53,11 +62,10 @@ Property empty() {
      */
     Property addRemove() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
-            Option<P2<Integer, String>> o = q.top();
-            Option<P2<Integer, String>> o2 = q.enqueue(i, s).dequeue().top();
-            return Property.impliesBoolean(
-                    q.isGreaterThan(Ord.intOrd, i),
-                    () -> o.equals(o2)
+            Option<P2<Integer, String>> t1 = q.top();
+            Option<P2<Integer, String>> t2 = q.enqueue(i, s).dequeue().top();
+            return prop(q.isLessThan(Ord.intOrd, i) ?
+                    t1.equals(t2) : t2.map(p -> p._1() >= i).orSome(true)
             );
         });
     }
@@ -75,20 +83,36 @@ Property emptyTop() {
     Property addTop() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
             Option<P2<Integer, String>> actual = q.enqueue(i, s).top();
-            return impliesBoolean(
-                    q.isGreaterThan(Ord.intOrd, i),
-                    actual.equals(some(P.p(i, s))));
+            return prop(q.isLessThan(Ord.intOrd, i) ? actual.equals(some(P.p(i, s))) : actual.equals(q.top()));
         });
     }
 
     /**
-     * Sorting a list returns the same as putting the list into a priority queue and getting
-     * the queue as a list.
+     * Sorting a list returns the same as putting the list into a priority queue and getting the queue as a list.
      */
     public Property sorted() {
         return property(arbPriorityQueueIntegerString, pq -> {
             List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
-            return prop(expected.equals(pq.toList()));
+            List<P2<Integer, String>> actual = pq.toList();
+            assertThat(actual, equalTo(expected));
+            return prop(actual.equals(expected));
+        });
+    }
+
+    /**
+     * Where the top n of the queue has just one element then:
+     * - Enqueueing and then topN of the queue should return a list of the top and the new item
+     * - Enqueuing and then dequeueing and then topping the queue should return the new item
+     */
+    Property singleTopSame() {
+        return property(arbPriorityQueueIntegerString, arbAlphaNumString, (pq, s) -> {
+            Option<Integer> o1 = pq.top().map(p -> p._1());
+            return o1.map(j -> {
+                boolean b = pq.topN().length() == 1;
+                Property p1 = impliesBoolean(b, () -> pq.enqueue(j, s).dequeue().top().equals(some(P.p(j, s))));
+                Property p2 = impliesBoolean(b, () -> pq.enqueue(j, s).topN().equals(List.list(pq.top().some(), P.p(j, s))));
+                return p1.and(p2);
+            }).orSome(prop(true));
         });
     }
 

From fc9f9bd0a5b7a933d5ec6b4c726aaf9928672ef9 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 18 Jun 2016 23:07:56 +1000
Subject: [PATCH 100/336] Added Ord.isLessThanOrEqualTo to Ord

---
 core/src/main/java/fj/Ord.java       | 13 +++++++++++++
 core/src/main/java/fj/data/List.java |  2 +-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 41b87f94..e9fb2d4b 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -92,6 +92,19 @@ public boolean isLessThan(final A a1, final A a2) {
     return compare(a1, a2) == Ordering.LT;
   }
 
+    /**
+     * Returns <code>true</code> if the first given argument is less than or equal to the second given argument,
+     * <code>false</code> otherwise.
+     *
+     * @param a1 An instance to compare for ordering to another.
+     * @param a2 An instance to compare for ordering to another.
+     * @return <code>true</code> if the first given argument is less than or equal to the second given argument,
+     *         <code>false</code> otherwise.
+     */
+    public boolean isLessThanOrEqualTo(final A a1, final A a2) {
+        return isLessThan(a1, a2) || eq(a1, a2);
+    }
+
   /**
    * Returns <code>true</code> if the first given argument is greater than the second given
    * argument, <code>false</code> otherwise.
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index d1f5ae63..c2d21b06 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -962,7 +962,7 @@ List<A> merge(List<A> xs, List<A> ys, final Ord<A> o) {
             final A x = xs.head();
             final A y = ys.head();
 
-            if (o.isLessThan(x, y) || o.eq(x, y)) {
+            if (o.isLessThanOrEqualTo(x, y)) {
               buf.snoc(x);
               xs = xs.tail();
             } else {

From 50433620e595ee70ab6aaa74ca6bed243b6ad382 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Tue, 7 Jun 2016 22:01:00 -0400
Subject: [PATCH 101/336] Add test for IO

---
 core/src/test/java/fj/IOTest.java | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 core/src/test/java/fj/IOTest.java

diff --git a/core/src/test/java/fj/IOTest.java b/core/src/test/java/fj/IOTest.java
new file mode 100644
index 00000000..f965204c
--- /dev/null
+++ b/core/src/test/java/fj/IOTest.java
@@ -0,0 +1,30 @@
+package fj;
+
+import fj.data.IO;
+import fj.data.IOFunctions;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+
+public class IOTest {
+
+    @Test
+    public void testLift() throws IOException {
+        final IO<String> readName = () -> new BufferedReader(new StringReader("foo")).readLine();
+        final F<String, IO<String>> upperCaseAndPrint = F1Functions.<String, IO<String>, String>o(this::println).f(String::toUpperCase);
+        final IO<String> readAndPrintUpperCasedName = IOFunctions.bind(readName, upperCaseAndPrint);
+        assertThat(readAndPrintUpperCasedName.run(), is("FOO"));
+    }
+
+    public IO<String> println(final String s) {
+        return () -> {
+            return s;
+        };
+    }
+}

From 371831331cdc41486c0814f801e497ab12a26ed6 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 19 Jun 2016 23:58:40 +1000
Subject: [PATCH 102/336] Added asserts, remove commented out and printlns from
 FingerTreeTest

---
 .../fj/data/fingertrees/FingerTreeTest.java   | 40 +++++--------------
 1 file changed, 10 insertions(+), 30 deletions(-)

diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 901c9c89..2a64b44b 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -20,6 +20,8 @@
  */
 public class FingerTreeTest {
 
+    public static final int SIZE = 10;
+
     @Test
     public void size() {
         validateSize(List.list(-92, 68, 54, -77, -18, 67));
@@ -36,20 +38,11 @@ void validateSize(List<Integer> list) {
 
     public FingerTree<Integer, Integer> midSeq() {
         FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
-        //        out.println(ft.toString());
-        return List.range(1, 10).foldLeft(ft2 -> i -> {
-            FingerTree<Integer, Integer> ft3 = ft2.snoc(i);
-//            out.println(ft3.toString());
-            return ft3;
-        }, ft);
+        return List.range(1, SIZE).foldLeft(ft2 -> i -> ft2.snoc(i), ft);
     }
 
-
-
     @Test
     public void testSeqString() {
-//        FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
-//        out.println(ft.toString());
         String actual = midSeq().toString();
         String expected = "Deep(9 -> One(1 -> 1), Deep(6 -> One(3 -> Node3(3 -> V3(2,3,4))), Empty(), One(3 -> Node3(3 -> V3(5,6,7)))), Two(2 -> V2(8,9)))";
         assertThat(actual, equalTo(expected));
@@ -57,47 +50,34 @@ public void testSeqString() {
 
     public FingerTree<Integer, P2<Integer, Integer>> midPriorityQueue() {
         FingerTree<Integer, P2<Integer, Integer>> ft = FingerTree.emptyIntMax();
-//        out.println(ft.toString());
-        return List.range(1, 10).foldLeft(ft2 -> i -> {
+        return List.range(1, SIZE).foldLeft(ft2 -> i -> {
             int j = i % 2 == 0 ? 2 * i : i;
             FingerTree<Integer, P2<Integer, Integer>> ft3 = ft2.snoc(P.p(j, j));
-//            out.println(ft3.toString());
             return ft3;
         }, ft);
     }
 
     @Test
     public void testQueueString() {
-//        FingerTree<Integer, P2<Integer, Integer>> ft = FingerTree.emptyIntMax();
-//        out.println(ft.toString());
         String actual = midPriorityQueue().toString();
         String expected = "Deep(16 -> One(1 -> (1,1)), Deep(12 -> One(8 -> Node3(8 -> V3((4,4),(3,3),(8,8)))), Empty(), One(12 -> Node3(12 -> V3((5,5),(12,12),(7,7))))), Two(16 -> V2((16,16),(9,9))))";
         assertThat(actual, equalTo(expected));
-
     }
 
     @Test
     public void stream() {
         FingerTree<Integer, Integer> ft = midSeq();
-        out.println(ft);
-        Stream<Integer> s = ft.toStream();
-        System.out.println(s.toList());
-
-        out.println(midPriorityQueue());
-        out.println(midPriorityQueue().toStream().toList());
+        assertThat(ft.toStream().toList(), equalTo(List.range(1, SIZE)));
     }
 
     @Test
     public void split() {
-
+        int splitPoint = 3;
         FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
-        FingerTree<Integer, Integer> ft3 = List.range(1, 10).foldLeft(ft2 -> i -> ft2.snoc(i), ft);
-        P2<FingerTree<Integer, Integer>, FingerTree<Integer, Integer>> p = ft3.split(v -> v >= 3);
-        Show<FingerTree<Integer, Integer>> fts = Show.fingerTreeShow(intShow, intShow);
-        Show<P2<FingerTree<Integer, Integer>, FingerTree<Integer, Integer>>> s = Show.p2Show(fts, fts);
-        System.out.println(s.showS(p));
-        System.out.println(p);
-
+        FingerTree<Integer, Integer> ft3 = List.range(1, SIZE).foldLeft(ft2 -> i -> ft2.snoc(i), ft);
+        P2<FingerTree<Integer, Integer>, FingerTree<Integer, Integer>> p = ft3.split(v -> v >= splitPoint);
+        assertThat(p._1().toStream().toList(), equalTo(List.range(1, splitPoint)));
+        assertThat(p._2().toStream().toList(), equalTo(List.range(splitPoint, SIZE)));
 
     }
 

From a506f0619cffc9a4b0820ada03f69012280195b4 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 20 Jun 2016 00:15:03 +1000
Subject: [PATCH 103/336] Implemented suggestons from @jbgi for PriorityQueue

---
 core/src/main/java/fj/data/PriorityQueue.java | 24 ++++++++++++-------
 .../properties/PriorityQueueProperties.java   |  1 -
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 0559ca00..49d185c9 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -13,11 +13,15 @@
 import static fj.data.List.list;
 
 /**
- * A priority queue implementation backed by a {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are annotated with type K, are combined using a monoid of K and both the key and value are stored in the leaf.  Priorities of the same value are returned FIFO (first in, first out).
+ * A priority queue implementation backed by a
+ * {@link fj.data.fingertrees.FingerTree}.  The finger tree nodes are
+ * annotated with type K, are combined using a monoid of K and both the
+ * key and value are stored in the leaf.  Priorities of the same value
+ * are returned FIFO (first in, first out).
  *
  * Created by MarkPerry on 31 May 16.
  */
-public class PriorityQueue<K, A> {
+public final class PriorityQueue<K, A> {
 
     private final FingerTree<K, P2<K, A>> ftree;
     private final Equal<K> equal;
@@ -31,7 +35,7 @@ private PriorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
      * Creates a priority queue from a finger tree.
      */
     public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K, P2<K, A>> ft) {
-        return new PriorityQueue<K, A>(e, ft);
+        return new PriorityQueue<>(e, ft);
     }
 
     /**
@@ -41,14 +45,14 @@ public static <K, A> PriorityQueue<K, A> priorityQueue(Equal<K> e, FingerTree<K,
      * @param e A value to compare key equality.
      */
     public static <K, A> PriorityQueue<K, A> empty(Monoid<K> m, Equal<K> e) {
-        return priorityQueue(e, FingerTree.empty(m, (P2<K, A> p) -> p._1()));
+        return priorityQueue(e, FingerTree.empty(m, P2.__1()));
     }
 
     /**
      * An empty priority queue with integer priorities.
      */
     public static <A> PriorityQueue<Integer, A> emptyInt() {
-        return priorityQueue(Equal.intEqual, FingerTree.empty(Monoid.intMaxMonoid, (P2<Integer, A> p) -> p._1()));
+        return empty(Monoid.intMaxMonoid, Equal.intEqual);
     }
 
     /**
@@ -56,8 +60,9 @@ public static <A> PriorityQueue<Integer, A> emptyInt() {
      */
     public <B> PriorityQueue<K, B> map(F<A, B> f) {
         return priorityQueue(equal,
-                ftree.map(p2 -> p2.map2(a -> f.f(a)),
-                FingerTree.measured(ftree.measured().monoid(), (P2<K, B> p2) -> p2._1()))
+                ftree.map(P2.map2_(f),
+                        FingerTree.measured(ftree.measured().monoid(), P2.__1())
+                )
         );
     }
 
@@ -91,6 +96,9 @@ public Option<P2<K, A>> top() {
         return p._2().headOption();
     }
 
+    /**
+     * Returns all the elements of the queue with the highest (same) priority.
+     */
     public List<P2<K, A>> topN() {
         Stream<P2<K, A>> s = toStream();
         if (s.isEmpty()) {
@@ -153,7 +161,7 @@ public PriorityQueue<K, A> dequeue() {
     /**
      * Returns a tuple of the node with the highest priority and the rest of the priority queue.
      */
-    public P2<Option<P2<K, A>>, PriorityQueue<K, A>> dequeueTop() {
+    public P2<Option<P2<K, A>>, PriorityQueue<K, A>> topDequeue() {
         return P.p(top(), dequeue());
     }
 
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index ba387cad..2bde7e6e 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -94,7 +94,6 @@ public Property sorted() {
         return property(arbPriorityQueueIntegerString, pq -> {
             List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
             List<P2<Integer, String>> actual = pq.toList();
-            assertThat(actual, equalTo(expected));
             return prop(actual.equals(expected));
         });
     }

From d2bd8cb2e91df657cee587b9fff87e016c59ce31 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 09:11:18 +0200
Subject: [PATCH 104/336] Added F1Functions#dimap (profunctor pattern)

---
 core/src/main/java/fj/F1Functions.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 7b97675a..3b46642f 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -677,4 +677,11 @@ public static <A, B, C> F<C, B> contramap(F<A, B> target, F<C, A> f) {
         return andThen(f, target);
     }
 
+    /**
+     * Both map (with g) and contramap (with f) the target function. (Profunctor pattern)
+     */
+    public static <A, B, C, D> F<C, D> dimap(F<A, B> target, F<C, A> f, F<B, D> g) {
+        return c -> g.f(target.f(f.f(c)));
+    }
+
 }

From d1f24b3609640fa41d08be8628fbc80611a3216b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 10:39:53 +0200
Subject: [PATCH 105/336] avoid andThen indirection in F1 map and contramap

---
 core/src/main/java/fj/F1Functions.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
index 3b46642f..00bdf515 100644
--- a/core/src/main/java/fj/F1Functions.java
+++ b/core/src/main/java/fj/F1Functions.java
@@ -670,11 +670,11 @@ public static <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
     }
 
     public static <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {
-        return andThen(target, f);
+        return o(f, target);
     }
 
     public static <A, B, C> F<C, B> contramap(F<A, B> target, F<C, A> f) {
-        return andThen(f, target);
+        return o(target, f);
     }
 
     /**

From 435109241022928961c01f877ee3a22e5438adab Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 10:41:18 +0200
Subject: [PATCH 106/336] add an uncurried version of Function.apply for better
 perf.

---
 core/src/main/java/fj/Function.java | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index 87888fad..f95b1c87 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -718,7 +718,18 @@ public static <A, B, C> F<C, B> bind(final F<C, A> ma, final F<A, F<C, B>> f) {
    * @return A new function after applying the given higher-order function to the given function.
    */
   public static <A, B, C> F<C, B> apply(final F<C, F<A, B>> cab, final F<C, A> ca) {
-    return bind(cab, f -> compose(f, ca));
+    return apply(uncurryF2(cab), ca);
+  }
+
+  /**
+   * Performs function application within a higher-order function (applicative functor pattern).
+   *
+   * @param cab The higher-order function to apply a function to.
+   * @param ca  A function to apply within a higher-order function.
+   * @return A new function after applying the given higher-order function to the given function.
+   */
+  public static <A, B, C> F<C, B> apply(final F2<C, A, B> cab, final F<C, A> ca) {
+    return c -> cab.f(c, ca.f(c));
   }
 
   /**

From 0704e22c5707ef8c6dbb1b459816bfba4a682ce9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 10:50:08 +0200
Subject: [PATCH 107/336] Ord: Take better advantage of the curried comparison
 function. also improved isLessThanOrEqualTo and simplified Ord instances of
 Comparable types.

---
 core/src/main/java/fj/Ord.java | 107 +++++++++++----------------------
 1 file changed, 34 insertions(+), 73 deletions(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index e9fb2d4b..04cc46b9 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -14,6 +14,8 @@
 import java.math.BigInteger;
 import java.util.Comparator;
 
+import static fj.Function.apply;
+import static fj.Function.compose;
 import static fj.Function.curry;
 import static fj.Semigroup.semigroup;
 
@@ -27,6 +29,8 @@ public final class Ord<A> {
 
   private Ord(final F<A, F<A, Ordering>> f) {
     this.f = f;
+    this.max = a1 -> apply((a2, o) -> o == Ordering.GT ? a1 : a2, f.f(a1));
+    this.min = a1 -> apply((a2, o) -> o == Ordering.LT ? a1 : a2, f.f(a1));
   }
 
   /**
@@ -66,7 +70,7 @@ public boolean eq(final A a1, final A a2) {
    * @return An <code>Equal</code> for this order.
    */
   public Equal<A> equal() {
-    return Equal.equal(curry(this::eq));
+    return Equal.equal(a -> compose(o -> o == Ordering.EQ, f.f(a)));
   }
 
   /**
@@ -102,7 +106,7 @@ public boolean isLessThan(final A a1, final A a2) {
      *         <code>false</code> otherwise.
      */
     public boolean isLessThanOrEqualTo(final A a1, final A a2) {
-        return isLessThan(a1, a2) || eq(a1, a2);
+        return compare(a1, a2) != Ordering.GT;
     }
 
   /**
@@ -125,7 +129,7 @@ public boolean isGreaterThan(final A a1, final A a2) {
    * @return A function that returns true if its argument is less than the argument to this method.
    */
   public F<A, Boolean> isLessThan(final A a) {
-    return a2 -> compare(a2, a) == Ordering.LT;
+    return compose(o -> o != Ordering.LT, f.f(a));
   }
 
   /**
@@ -135,7 +139,7 @@ public F<A, Boolean> isLessThan(final A a) {
    * @return A function that returns true if its argument is greater than the argument to this method.
    */
   public F<A, Boolean> isGreaterThan(final A a) {
-    return a2 -> compare(a2, a) == Ordering.GT;
+    return compose(o -> o != Ordering.GT, f.f(a));
   }
 
   /**
@@ -164,19 +168,19 @@ public A min(final A a1, final A a2) {
   /**
    * A function that returns the greater of its two arguments.
    */
-  public final F<A, F<A, A>> max = curry(this::max);
+  public final F<A, F<A, A>> max;
 
   /**
    * A function that returns the lesser of its two arguments.
    */
-  public final F<A, F<A, A>> min = curry(this::min);
+  public final F<A, F<A, A>> min;
 
   public final Semigroup<A> minSemigroup() {
-      return semigroup(this::min);
+      return semigroup(min);
   }
 
   public final Semigroup<A> maxSemigroup() {
-      return semigroup(this::max);
+      return semigroup(max);
   }
 
   public final Ord<A> reverse() { return ord(Function.flip(f)); }
@@ -194,92 +198,52 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
   /**
    * An order instance for the <code>boolean</code> type.
    */
-  public static final Ord<Boolean> booleanOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Boolean> booleanOrd = comparableOrd();
 
   /**
    * An order instance for the <code>byte</code> type.
    */
-  public static final Ord<Byte> byteOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Byte> byteOrd = comparableOrd();
 
   /**
    * An order instance for the <code>char</code> type.
    */
-  public static final Ord<Character> charOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Character> charOrd = comparableOrd();
 
   /**
    * An order instance for the <code>double</code> type.
    */
-  public static final Ord<Double> doubleOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Double> doubleOrd = comparableOrd();
 
   /**
    * An order instance for the <code>float</code> type.
    */
-  public static final Ord<Float> floatOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Float> floatOrd = comparableOrd();
 
   /**
    * An order instance for the <code>int</code> type.
    */
-  public static final Ord<Integer> intOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Integer> intOrd = comparableOrd();
 
   /**
    * An order instance for the <code>BigInteger</code> type.
    */
-  public static final Ord<BigInteger> bigintOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<BigInteger> bigintOrd = comparableOrd();
 
   /**
    * An order instance for the <code>BigDecimal</code> type.
    */
-  public static final Ord<BigDecimal> bigdecimalOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<BigDecimal> bigdecimalOrd = comparableOrd();
 
   /**
    * An order instance for the <code>long</code> type.
    */
-  public static final Ord<Long> longOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Long> longOrd = comparableOrd();
 
   /**
    * An order instance for the <code>short</code> type.
    */
-  public static final Ord<Short> shortOrd = ord(
-          a1 -> a2 -> {
-            final int x = a1.compareTo(a2);
-            return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<Short> shortOrd = comparableOrd();
 
   /**
    * An order instance for the {@link Ordering} type.
@@ -297,23 +261,17 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
   /**
    * An order instance for the {@link String} type.
    */
-  public static final Ord<String> stringOrd = ord(
-          a1 -> a2 -> {
-              final int x = a1.compareTo(a2);
-              return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
-          });
+  public static final Ord<String> stringOrd = comparableOrd();
 
   /**
    * An order instance for the {@link StringBuffer} type.
    */
-  public static final Ord<StringBuffer> stringBufferOrd =
-      ord(a1 -> a2 -> stringOrd.compare(a1.toString(), a2.toString()));
+  public static final Ord<StringBuffer> stringBufferOrd = stringOrd.contramap(StringBuffer::toString);
 
   /**
    * An order instance for the {@link StringBuffer} type.
    */
-  public static final Ord<StringBuilder> stringBuilderOrd =
-      ord(a1 -> a2 -> stringOrd.compare(a1.toString(), a2.toString()));
+  public static final Ord<StringBuilder> stringBuilderOrd = stringOrd.contramap(StringBuilder::toString);
 
   /**
    * An order instance for the {@link Option} type.
@@ -527,9 +485,9 @@ public static <A extends Comparable<A>> Ord<A> comparableOrd() {
    * @see #hashEqualsOrd()
    */
   public static <A> Ord<A> hashOrd() {
-    return ord(a -> a2 -> {
-        final int x = a.hashCode() - a2.hashCode();
-        return x < 0 ? Ordering.LT : x == 0 ? Ordering.EQ : Ordering.GT;
+    return ord(a -> {
+      int aHash = a.hashCode();
+      return a2 -> Ordering.fromInt(Integer.compare(aHash, a2.hashCode()));
     });
   }
 
@@ -541,9 +499,12 @@ public static <A> Ord<A> hashOrd() {
    * @return An order instance that is based on {@link Object#hashCode()} and {@link Object#equals}.
    */
   public static <A> Ord<A> hashEqualsOrd() {
-    return ord(a -> a2 -> {
-        final int x = a.hashCode() - a2.hashCode();
-        return x < 0 ? Ordering.LT : x == 0 && a.equals(a2) ? Ordering.EQ : Ordering.GT;
+    return ord(a -> {
+      int aHash = a.hashCode();
+      return a2 -> {
+        final int a2Hash = a2.hashCode();
+        return aHash < a2Hash ? Ordering.LT : aHash == a2Hash && a.equals(a2) ? Ordering.EQ : Ordering.GT;
+      };
     });
   }
 

From 3812a832501f4b7be4024347c1e8f1fa89c45125 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 14:51:08 +0200
Subject: [PATCH 108/336] Add uncons  to FingerTree

---
 .../main/java/fj/data/fingertrees/FingerTree.java    | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index ee985611..160b5508 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -167,6 +167,18 @@ public final Option<A> headOption() {
       return isEmpty() ? Option.none() : Option.some(head());
   }
 
+  /**
+   * Performs a reduction on this finger tree using the given arguments.
+   *
+   * @param nil  The value to return if this finger tree is empty.
+   * @param cons The function to apply to the head and tail of this finger tree  if it is not empty.
+   * @return A reduction on this finger tree.
+   */
+  public final <B> B uncons(B nil, F2<A, FingerTree<V, A>, B> cons) {
+    return isEmpty() ? nil : cons.f(head(), tail());
+  }
+
+
   /**
    * The last element of this tree. This is an O(1) operation.
    *

From f21c310653b6f06d6d05c70030c6bbe1807408cd Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 19 Jun 2016 14:55:24 +0200
Subject: [PATCH 109/336] Add PriorityQueue.unqueue and use it to implement
 some other methods. + some other minor refactoring.

---
 core/src/main/java/fj/data/PriorityQueue.java | 54 +++++++++++--------
 1 file changed, 32 insertions(+), 22 deletions(-)

diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 49d185c9..2649a253 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -2,15 +2,17 @@
 
 import fj.Equal;
 import fj.F;
+import fj.F2;
 import fj.Monoid;
 import fj.Ord;
 import fj.P;
 import fj.P2;
-import fj.P3;
 import fj.Show;
 import fj.data.fingertrees.FingerTree;
 
-import static fj.data.List.list;
+import static fj.Function.compose;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
 
 /**
  * A priority queue implementation backed by a
@@ -91,22 +93,17 @@ public boolean isEmpty() {
      * If the tree is not empty, returns the node with highest priority otherwise returns nothing.
      */
     public Option<P2<K, A>> top() {
-        K top = ftree.measure();
-        P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(top, k));
-        return p._2().headOption();
+        return unqueue(none(), (top, tail) -> some(top));
     }
 
     /**
      * Returns all the elements of the queue with the highest (same) priority.
      */
     public List<P2<K, A>> topN() {
-        Stream<P2<K, A>> s = toStream();
-        if (s.isEmpty()) {
-            return List.nil();
-        } else {
-            final K k = s.head()._1();
-            return s.takeWhile(p -> equal.eq(k, p._1())).toList();
-        }
+        return toStream().uncons(
+            List.nil(),
+            top -> tail -> List.cons(top, tail._1().takeWhile(compose(equal.eq(top._1()), P2.__1())).toList())
+        );
     }
 
     /**
@@ -127,7 +124,7 @@ public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
      * Does the priority k exist already?
      */
     public boolean contains(final K k) {
-        return !ftree.split(k2 -> equal.eq(k, k2))._2().isEmpty();
+        return !ftree.split(equal.eq(k))._2().isEmpty();
     }
 
     /**
@@ -152,17 +149,30 @@ public PriorityQueue<K, A> enqueue(P2<K, A> p) {
      * Removes the node with the highest priority.
      */
     public PriorityQueue<K, A> dequeue() {
-        K top = ftree.measure();
-        P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(k -> equal.eq(k, top));
-        FingerTree<K, P2<K, A>> right = p._2();
-        return right.isEmpty() ? this : priorityQueue(equal, p._1().append(right.tail()));
+        return unqueue(this, (top, tail) -> tail);
     }
 
     /**
      * Returns a tuple of the node with the highest priority and the rest of the priority queue.
      */
     public P2<Option<P2<K, A>>, PriorityQueue<K, A>> topDequeue() {
-        return P.p(top(), dequeue());
+        return unqueue(P.p(none(), this), (top, tail) -> P.p(some(top), tail));
+    }
+
+    /**
+     * Performs a reduction on this priority queue using the given arguments.
+     *
+     * @param empty  The value to return if this queue is empty.
+     * @param topDequeue The function to apply to the top priority element and the tail of the queue (without its top element).
+     * @return A reduction on this queue.
+     */
+    public <B> B unqueue(B empty, F2<P2<K, A>, PriorityQueue<K, A>, B> topDequeue) {
+        K top = ftree.measure();
+        P2<FingerTree<K, P2<K, A>>, FingerTree<K, P2<K, A>>> p = ftree.split(equal.eq(top));
+        return p._2().uncons(
+            empty,
+            (head, tail) -> topDequeue.f(head, priorityQueue(equal, p._1().append(tail)))
+        );
     }
 
     /**
@@ -182,22 +192,22 @@ public PriorityQueue<K, A> dequeue(int n) {
      * Does the top of the queue have lower priority than k?
      */
     public boolean isLessThan(Ord<K> ok, K k) {
-        return top().map(p -> ok.isLessThan(p._1(), k)).orSome(true);
+        return top().option(true, p -> ok.isLessThan(p._1(), k));
     }
 
     public boolean isGreaterThan(Ord<K> ok, K k) {
-        return top().map(p -> ok.isGreaterThan(p._1(), k)).orSome(false);
+        return top().option(false, p -> ok.isGreaterThan(p._1(), k));
     }
 
     public boolean isEqual(Ord<K> ok, K k) {
-        return top().map(p -> ok.eq(p._1(), k)).orSome(false);
+        return top().option(false, p -> ok.eq(p._1(), k));
     }
 
     /**
      * Returns a stream of products with priority k and value a.
      */
     public Stream<P2<K, A>> toStream() {
-        return top().map(p -> Stream.cons(p, () -> dequeue().toStream())).orSome(() -> Stream.nil());
+        return unqueue(Stream.nil(), (top, tail) -> Stream.cons(top, () -> tail.toStream()));
     }
 
     /**

From 17efc98972b07644248ae8dec8d3bcbdd56fe66a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:04:58 +0200
Subject: [PATCH 110/336] remove old workaround for javac bugs that have been
 fixed.

---
 core/src/main/java/fj/control/Trampoline.java | 14 ++++++--------
 core/src/main/java/fj/data/List.java          |  5 +----
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index cd477dd0..37491c3b 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -52,14 +52,12 @@ public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
     // gets shifted into the continuation.
     public Either<P1<Trampoline<A>>, A> resume() {
-      return left(sub.resume().either(p -> p.map(ot -> {
-        // WARNING: In JDK 8, update 25 (current version) the following code is a
-        // workaround for an internal JDK compiler error, likely due to
-        // https:bugs.openjdk.java.net/browse/JDK-8062253.
-        F<Normal<Object>, Trampoline<A>> f = o -> o.foldNormal(cont, t -> t._1().bind(cont));
-        F<Codense<Object>, Trampoline<A>> g = c -> codense(c.sub, o -> c.cont.f(o).bind(cont));
-        return ot.fold(f, g);
-      }), o -> P.lazy(() -> cont.f(o))));
+      return left(sub.resume().either(p -> p.map(ot ->
+          ot.fold(
+              o -> o.foldNormal(cont, t -> t._1().bind(cont)),
+              c -> codense(c.sub, o -> c.cont.f(o).bind(cont))
+          )
+      ), o -> P.lazy(() -> cont.f(o))));
     }
   }
 
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index c2d21b06..c7e1562f 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -88,10 +88,7 @@ public final Iterator<A> iterator() {
    * @return The length of this list.
    */
   public final int length() {
-    // WARNING: In JDK 8, update 25 (current version) the following code triggers an internal JDK compiler error, likely due to https://bugs.openjdk.java.net/browse/JDK-8062253.   The code below is a workaround for this compiler bug.
-    //    return foldLeft(i -> a -> i + 1, 0);
-    F2<Integer, A, Integer> f = (i, a) -> i + 1;
-    return foldLeft(f, 0);
+    return foldLeft((i, a) -> i + 1, 0);
   }
 
   /**

From 9983ab260fe7a7efb297106f8f967906a5360570 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:23:31 +0200
Subject: [PATCH 111/336] Use uncurried version of foldLeft as default
 implementation to avoid creation of closures in tight loop.

---
 core/src/main/java/fj/data/List.java          | 30 +++++++++----------
 core/src/main/java/fj/data/PriorityQueue.java |  2 +-
 core/src/main/java/fj/data/Stream.java        | 30 ++++++++-----------
 3 files changed, 29 insertions(+), 33 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index c2d21b06..48e93e32 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -751,13 +751,7 @@ public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
-    B x = b;
-
-    for (List<A> xs = this; !xs.isEmpty(); xs = xs.tail()) {
-      x = f.f(x).f(xs.head());
-    }
-
-    return x;
+    return foldLeft(uncurryF2(f), b);
   }
 
   /**
@@ -768,7 +762,13 @@ public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
-    return foldLeft(curry(f), b);
+    B x = b;
+
+    for (List<A> xs = this; !xs.isEmpty(); xs = xs.tail()) {
+      x = f.f(x, xs.head());
+    }
+
+    return x;
   }
 
   /**
@@ -779,7 +779,9 @@ public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F2<A, A, A> f) {
-    return foldLeft1(curry(f));
+    if (isEmpty())
+      throw error("Undefined: foldLeft1 on empty list");
+    return tail().foldLeft(f, head());
   }
 
   /**
@@ -790,9 +792,7 @@ public final A foldLeft1(final F2<A, A, A> f) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F<A, F<A, A>> f) {
-    if (isEmpty())
-      throw error("Undefined: foldLeft1 on empty list");
-    return tail().foldLeft(f, head());
+    return foldLeft1(uncurryF2(f));
   }
 
   /**
@@ -801,7 +801,7 @@ public final A foldLeft1(final F<A, F<A, A>> f) {
    * @return A new list that is the reverse of this one.
    */
   public final List<A> reverse() {
-    return foldLeft(as -> a -> cons(a, as), List.nil());
+    return foldLeft((as, a) -> cons(a, as), nil());
   }
 
   /**
@@ -904,7 +904,7 @@ public final List<List<A>> partition(final int n) {
    * @param f Predicate function.
    */
   public final P2<List<A>, List<A>> partition(F<A, Boolean> f) {
-    P2<List<A>, List<A>> p2 = foldLeft(acc -> a ->
+    P2<List<A>, List<A>> p2 = foldLeft((acc, a) ->
       f.f(a) ? p(acc._1().cons(a), acc._2()) : p(acc._1(), acc._2().cons(a)),
       p(nil(), nil())
     );
@@ -1393,7 +1393,7 @@ public final <B, C, D> TreeMap<B, D> groupBy(
       final D groupingIdentity,
       final F2<C, D, D> groupingAcc,
       final Ord<B> keyOrd) {
-    return this.foldLeft(map -> element -> {
+    return this.foldLeft((map, element) -> {
           final B key = keyFunction.f(element);
           final C value = valueFunction.f(element);
           return map.set(key, map.get(key)
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 2649a253..21f6ed6f 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -117,7 +117,7 @@ public PriorityQueue<K, A> enqueue(K k, A a) {
      * Adds nodes using the list of products with priority k and value a.  This operation takes O(list.length()).
      */
     public PriorityQueue<K, A> enqueue(List<P2<K, A>> list) {
-        return list.foldLeft(pq -> p -> pq.enqueue(p._1(), p._2()), this);
+        return list.foldLeft((pq, p) -> pq.enqueue(p._1(), p._2()), this);
     }
 
     /**
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index ca4c870a..ae37d714 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -22,11 +22,7 @@
 import java.util.*;
 
 import static fj.Bottom.error;
-import static fj.Function.compose;
-import static fj.Function.constant;
-import static fj.Function.curry;
-import static fj.Function.flip;
-import static fj.Function.identity;
+import static fj.Function.*;
 import static fj.P.p;
 import static fj.P.p2;
 import static fj.Unit.unit;
@@ -167,12 +163,7 @@ public final <B> B foldRight1(final F2<A, B, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
-    B x = b;
-
-    for (Stream<A> xs = this; !xs.isEmpty(); xs = xs.tail()._1())
-      x = f.f(x).f(xs.head());
-
-    return x;
+    return foldLeft(uncurryF2(f), b);
   }
 
   /**
@@ -183,7 +174,12 @@ public final <B> B foldLeft(final F<B, F<A, B>> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
-    return foldLeft(curry(f), b);
+    B x = b;
+
+    for (Stream<A> xs = this; !xs.isEmpty(); xs = xs.tail()._1())
+      x = f.f(x, xs.head());
+
+    return x;
   }
 
   /**
@@ -194,7 +190,9 @@ public final <B> B foldLeft(final F2<B, A, B> f, final B b) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F2<A, A, A> f) {
-    return foldLeft1(curry(f));
+    if (isEmpty())
+      throw error("Undefined: foldLeft1 on empty list");
+    return tail()._1().foldLeft(f, head());
   }
 
   /**
@@ -205,9 +203,7 @@ public final A foldLeft1(final F2<A, A, A> f) {
    * @return The final result after the left-fold reduction.
    */
   public final A foldLeft1(final F<A, F<A, A>> f) {
-    if (isEmpty())
-      throw error("Undefined: foldLeft1 on empty list");
-    return tail()._1().foldLeft(f, head());
+    return foldLeft1(uncurryF2(f));
   }
 
   /**
@@ -1188,7 +1184,7 @@ public final P2<Stream<A>, Stream<A>> split(final F<A, Boolean> p) {
    * @return A new stream that is the reverse of this one.
    */
   public final Stream<A> reverse() {
-    return foldLeft(as -> a -> cons(a, () -> as), Stream.nil());
+    return foldLeft((as, a) -> cons(a, () -> as), Stream.nil());
   }
 
   /**

From cab3299d677dda81ade19849e18119e24ba35ea9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:29:33 +0200
Subject: [PATCH 112/336] Add first class either catamorphism

---
 core/src/main/java/fj/data/Either.java | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index a4f0fc02..c0c143af 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -737,6 +737,17 @@ public static <A, B> Either<A, B> right(final B b) {
     return new Right<>(b);
   }
 
+  /**
+   * First class catamorphism for either. Folds over this either breaking into left or right.
+   *
+   * @param left  The function to call if this is left.
+   * @param right The function to call if this is right.
+   * @return The reducing function.
+   */
+  public static <A, B, X> F<Either<A,B>, X> cata(final F<A, X> left, final F<B, X> right) {
+    return e -> e.either(left, right);
+  }
+
   /**
    * @return A function that maps another function across an either's left projection.
    */

From 7c2605ec48ce183b388d9d9a1b71bd936de63658 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:54:48 +0200
Subject: [PATCH 113/336] Add first class option catamorphism

---
 core/src/main/java/fj/data/Option.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 4cdb411f..f1b228d0 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -688,6 +688,18 @@ public static <T> F<T, Option<T>> fromNull() {
     return Option::fromNull;
   }
 
+  /**
+   * First-class catamorphism for Option: return a function that will performs
+   * a reduction on an optional value using the given arguments.
+   *
+   * @param none The value to return if this optional value has no value.
+   * @param some The function to apply to the value of this optional value.
+   * @return the reducing function.
+   */
+  public static final <A, B> F<Option<A>, B> cata(final B none, final F<A, B> some) {
+    return o -> o.option(none, some);
+  }
+
   /**
    * Joins the given optional value of optional value using a bind operation.
    *

From 25d10ea69eb94036f98bfbcb022aa7442edbfb9b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 23:29:43 +0200
Subject: [PATCH 114/336] Initial implementation of optimizable definitions for
 Equal

---
 core/src/main/java/fj/Equal.java | 167 ++++++++++++++++++++++++-------
 1 file changed, 130 insertions(+), 37 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index a09dceba..bb10f442 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -1,8 +1,19 @@
 package fj;
 
-import static fj.Function.curry;
-
-import fj.data.*;
+import fj.data.Array;
+import fj.data.Either;
+import fj.data.LazyString;
+import fj.data.List;
+import fj.data.Natural;
+import fj.data.NonEmptyList;
+import fj.data.Option;
+import fj.data.Seq;
+import fj.data.Set;
+import fj.data.Stream;
+import fj.data.Tree;
+import fj.data.TreeMap;
+import fj.data.Validation;
+import fj.data.Writer;
 import fj.data.hlist.HList;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
@@ -12,8 +23,12 @@
 import fj.data.vector.V7;
 import fj.data.vector.V8;
 
-import java.math.BigInteger;
 import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import static fj.Function.compose;
+import static fj.Function.constant;
+import static fj.Function.curry;
 
 /**
  * Tests for equality between two objects.
@@ -21,10 +36,37 @@
  * @version %build.number%
  */
 public final class Equal<A> {
-  private final F<A, F<A, Boolean>> f;
 
-  private Equal(final F<A, F<A, Boolean>> f) {
-    this.f = f;
+  /**
+   * Primitives functions of Equal: minimal definition and overridable methods.
+   */
+  interface Definition<A> {
+
+    F<A, Boolean> equal(A a);
+
+    default boolean equal(A a1, A a2) {
+      return equal(a1).f(a2);
+    }
+  }
+
+  /**
+   * Primitives functions of Equal: alternative minimal definition and overridable methods.
+   */
+  interface AlternateDefinition<A> extends Definition<A> {
+
+    @Override
+    default F<A, Boolean> equal(A a) {
+      return a2 -> equal(a, a2);
+    }
+
+    @Override
+    boolean equal(A a1, A a2);
+  }
+
+  private final Definition<A> def;
+
+  private Equal(final Definition<A> def) {
+    this.def = def;
   }
 
   /**
@@ -35,7 +77,7 @@ private Equal(final F<A, F<A, Boolean>> f) {
    * @return <code>true</code> if the two given arguments are equal, <code>false</code> otherwise.
    */
   public boolean eq(final A a1, final A a2) {
-    return f.f(a1).f(a2);
+    return def.equal(a1, a2);
   }
 
   /**
@@ -46,7 +88,7 @@ public boolean eq(final A a1, final A a2) {
    * @return <code>true</code> if the two given arguments are not equal, <code>false</code> otherwise.
    */
   public boolean notEq(final A a1, final A a2) {
-    return !eq(a1, a2);
+    return !def.equal(a1, a2);
   }
 
   /**
@@ -55,7 +97,7 @@ public boolean notEq(final A a1, final A a2) {
    * @return A function that returns <code>true</code> if the two given arguments are equal.
    */
   public F2<A, A, Boolean> eq() {
-    return this::eq;
+    return def::equal;
   }
 
   /**
@@ -65,7 +107,7 @@ public F2<A, A, Boolean> eq() {
    * @return A function that returns <code>true</code> if the given argument equals the argument to this method.
    */
   public F<A, Boolean> eq(final A a) {
-    return f.f(a);
+    return def.equal(a);
   }
 
   /**
@@ -75,7 +117,18 @@ public F<A, Boolean> eq(final A a) {
    * @return A new equal.
    */
   public <B> Equal<B> contramap(final F<B, A> f) {
-    return equal(F1Functions.o(F1Functions.o(F1Functions.andThen(f), this.f), f));
+    Definition<A> eaDef = def;
+    return equalDef(new Definition<B>(){
+      @Override
+      public F<B, Boolean> equal(B b) {
+        return compose(eaDef.equal(f.f(b)), f);
+      }
+
+      @Override
+      public boolean equal(B b1, B b2) {
+        return eaDef.equal(f.f(b1), f.f(b2));
+      }
+    });
   }
 
   /**
@@ -85,7 +138,27 @@ public <B> Equal<B> contramap(final F<B, A> f) {
    * @return An equal instance from the given function.
    */
   public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
-    return new Equal<>(f);
+    return new Equal<>(f::f);
+  }
+
+  /**
+   * Constructs an equal instance from the given definition.
+   *
+   * @param definition The minimal definition of the equal instance.
+   * @return An equal instance from the given function.
+   */
+  public static <A> Equal<A> equalDef(final Definition<A> definition) {
+    return new Equal<>(definition);
+  }
+
+  /**
+   * Constructs an equal instance from the given definition.
+   *
+   * @param definition The minimal definition of the equal instance.
+   * @return An equal instance from the given function.
+   */
+  public static <A> Equal<A> equalAltDef(final AlternateDefinition<A> definition) {
+    return new Equal<>(definition);
   }
 
   /**
@@ -96,7 +169,17 @@ public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
    *         equality.
    */
   public static <A> Equal<A> anyEqual() {
-    return equal(a1 -> a1::equals);
+    return equalDef(new Definition<A>() {
+      @Override
+      public F<A, Boolean> equal(A a) {
+        return a::equals;
+      }
+
+      @Override
+      public boolean equal(A a1, A a2) {
+        return a1.equals(a2);
+      }
+    });
   }
 
   /**
@@ -163,7 +246,7 @@ public static <A> Equal<A> anyEqual() {
    * An equal instance for the {@link StringBuffer} type.
    */
   public static final Equal<StringBuffer> stringBufferEqual =
-      equal(sb1 -> sb2 -> {
+      equalAltDef((sb1, sb2) -> {
         if (sb1.length() == sb2.length()) {
           for (int i = 0; i < sb1.length(); i++)
             if (sb1.charAt(i) != sb2.charAt(i))
@@ -177,7 +260,7 @@ public static <A> Equal<A> anyEqual() {
    * An equal instance for the {@link StringBuilder} type.
    */
   public static final Equal<StringBuilder> stringBuilderEqual =
-      equal(sb1 -> sb2 -> {
+      equalAltDef((sb1, sb2) -> {
         if (sb1.length() == sb2.length()) {
           for (int i = 0; i < sb1.length(); i++)
             if (sb1.charAt(i) != sb2.charAt(i))
@@ -195,8 +278,12 @@ public static <A> Equal<A> anyEqual() {
    * @return An equal instance for the {@link Either} type.
    */
   public static <A, B> Equal<Either<A, B>> eitherEqual(final Equal<A> ea, final Equal<B> eb) {
-    return equal(e1 -> e2 -> e1.isLeft() && e2.isLeft() && ea.f.f(e1.left().value()).f(e2.left().value()) ||
-           e1.isRight() && e2.isRight() && eb.f.f(e1.right().value()).f(e2.right().value()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    return equalDef(e1 -> e1.either(
+        a1 -> Either.cata(eaDef.equal(a1), (B __) -> false),
+        b1 -> Either.cata((A __)-> false, ebDef.equal(b1))
+    ));
   }
 
   /**
@@ -217,12 +304,13 @@ public static <A, B> Equal<Validation<A, B>> validationEqual(final Equal<A> ea,
    * @return An equal instance for the {@link List} type.
    */
   public static <A> Equal<List<A>> listEqual(final Equal<A> ea) {
-    return equal(a1 -> a2 -> {
+    Definition<A> eaDef = ea.def;
+    return equalAltDef((a1, a2) -> {
       List<A> x1 = a1;
       List<A> x2 = a2;
 
       while (x1.isNotEmpty() && x2.isNotEmpty()) {
-        if (!ea.eq(x1.head(), x2.head()))
+        if (!eaDef.equal(x1.head(), x2.head()))
           return false;
 
         x1 = x1.tail();
@@ -250,12 +338,15 @@ public static <A> Equal<NonEmptyList<A>> nonEmptyListEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link Option} type.
    */
   public static <A> Equal<Option<A>> optionEqual(final Equal<A> ea) {
-    return equal(o1 -> o2 -> o1.isNone() && o2.isNone() ||
-           o1.isSome() && o2.isSome() && ea.f.f(o1.some()).f(o2.some()));
+    Definition<A> eaDef = ea.def;
+    return equalDef(o1 -> o1.option(
+        Option.isNone_(),
+        a1 -> Option.cata(false, eaDef.equal(a1))
+    ));
   }
 
   public static <A> Equal<Seq<A>> seqEqual(final Equal<A> e) {
-    return equal(s1 -> s2 -> streamEqual(e).eq(s1.toStream(), s2.toStream()));
+    return streamEqual(e).contramap(Seq::toStream);
   }
 
   /**
@@ -265,12 +356,13 @@ public static <A> Equal<Seq<A>> seqEqual(final Equal<A> e) {
    * @return An equal instance for the {@link Stream} type.
    */
   public static <A> Equal<Stream<A>> streamEqual(final Equal<A> ea) {
-    return equal(a1 -> a2 -> {
+    Definition<A> eaDef = ea.def;
+    return equalAltDef((a1, a2) -> {
       Stream<A> x1 = a1;
       Stream<A> x2 = a2;
 
       while (x1.isNotEmpty() && x2.isNotEmpty()) {
-        if (!ea.eq(x1.head(), x2.head()))
+        if (!eaDef.equal(x1.head(), x2.head()))
           return false;
 
         x1 = x1.tail()._1();
@@ -288,10 +380,11 @@ public static <A> Equal<Stream<A>> streamEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link Array} type.
    */
   public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
-    return equal(a1 -> a2 -> {
+    Definition<A> eaDef = ea.def;
+    return equalAltDef((a1, a2) -> {
       if (a1.length() == a2.length()) {
         for (int i = 0; i < a1.length(); i++) {
-          if (!ea.eq(a1.get(i), a2.get(i)))
+          if (!eaDef.equal(a1.get(i), a2.get(i)))
             return false;
         }
         return true;
@@ -307,7 +400,7 @@ public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link Tree} type.
    */
   public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
-    return Equal.equal(curry((t1, t2) -> ea.eq(t1.root(), t2.root()) && p1Equal(streamEqual(Equal.treeEqual(ea))).eq(t2.subForest(), t1.subForest())));
+    return equalAltDef((t1, t2) -> ea.eq(t1.root(), t2.root()) && p1Equal(streamEqual(treeEqual(ea))).eq(t2.subForest(), t1.subForest()));
   }
 
   /**
@@ -317,7 +410,7 @@ public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
    * @return An equal instance for a product-1.
    */
   public static <A> Equal<P1<A>> p1Equal(final Equal<A> ea) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()));
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()));
   }
 
   /**
@@ -328,7 +421,7 @@ public static <A> Equal<P1<A>> p1Equal(final Equal<A> ea) {
    * @return An equal instance for a product-2.
    */
   public static <A, B> Equal<P2<A, B>> p2Equal(final Equal<A> ea, final Equal<B> eb) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()));
+    return equalAltDef((p1, p2)-> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()));
   }
 
   /**
@@ -340,7 +433,7 @@ public static <A, B> Equal<P2<A, B>> p2Equal(final Equal<A> ea, final Equal<B> e
    * @return An equal instance for a product-3.
    */
   public static <A, B, C> Equal<P3<A, B, C>> p3Equal(final Equal<A> ea, final Equal<B> eb, final Equal<C> ec) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()));
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()));
   }
 
   /**
@@ -354,7 +447,7 @@ public static <A, B, C> Equal<P3<A, B, C>> p3Equal(final Equal<A> ea, final Equa
    */
   public static <A, B, C, D> Equal<P4<A, B, C, D>> p4Equal(final Equal<A> ea, final Equal<B> eb, final Equal<C> ec,
                                                            final Equal<D> ed) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
            ed.eq(p1._4(), p2._4()));
   }
 
@@ -371,7 +464,7 @@ public static <A, B, C, D> Equal<P4<A, B, C, D>> p4Equal(final Equal<A> ea, fina
   public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea, final Equal<B> eb,
                                                                  final Equal<C> ec, final Equal<D> ed,
                                                                  final Equal<E> ee) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
            ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()));
   }
 
@@ -389,7 +482,7 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
   public static <A, B, C, D, E, F$> Equal<P6<A, B, C, D, E, F$>> p6Equal(final Equal<A> ea, final Equal<B> eb,
                                                                          final Equal<C> ec, final Equal<D> ed,
                                                                          final Equal<E> ee, final Equal<F$> ef) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
            ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()));
   }
 
@@ -409,7 +502,7 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
                                                                                final Equal<C> ec, final Equal<D> ed,
                                                                                final Equal<E> ee, final Equal<F$> ef,
                                                                                final Equal<G> eg) {
-    return equal(p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
+    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
            ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()) &&
            eg.eq(p1._7(), p2._7()));
   }
@@ -435,8 +528,8 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
                                                                                      final Equal<F$> ef,
                                                                                      final Equal<G> eg,
                                                                                      final Equal<H> eh) {
-    return equal(
-            p1 -> p2 -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
+    return equalAltDef(
+        (p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
                    ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()) &&
                    eg.eq(p1._7(), p2._7()) && eh.eq(p1._8(), p2._8()));
   }

From 6945c784a98afccec1089f570f72d20f5cbcb193 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Wed, 22 Jun 2016 20:40:36 +0200
Subject: [PATCH 115/336] Finish migrating Equal to use optimizable definition

---
 core/src/main/java/fj/Equal.java | 114 ++++++++++++++++++++++---------
 1 file changed, 81 insertions(+), 33 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index bb10f442..e5b2ebb1 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -54,13 +54,13 @@ default boolean equal(A a1, A a2) {
    */
   interface AlternateDefinition<A> extends Definition<A> {
 
+    @Override
+    boolean equal(A a1, A a2);
+
     @Override
     default F<A, Boolean> equal(A a) {
       return a2 -> equal(a, a2);
     }
-
-    @Override
-    boolean equal(A a1, A a2);
   }
 
   private final Definition<A> def;
@@ -144,7 +144,7 @@ public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
   /**
    * Constructs an equal instance from the given definition.
    *
-   * @param definition The minimal definition of the equal instance.
+   * @param definition a definition of the equal instance.
    * @return An equal instance from the given function.
    */
   public static <A> Equal<A> equalDef(final Definition<A> definition) {
@@ -152,12 +152,12 @@ public static <A> Equal<A> equalDef(final Definition<A> definition) {
   }
 
   /**
-   * Constructs an equal instance from the given definition.
+   * Constructs an equal instance from the given (alternative) definition.
    *
-   * @param definition The minimal definition of the equal instance.
+   * @param definition a definition of the equal instance.
    * @return An equal instance from the given function.
    */
-  public static <A> Equal<A> equalAltDef(final AlternateDefinition<A> definition) {
+  public static <A> Equal<A> equalDef(final AlternateDefinition<A> definition) {
     return new Equal<>(definition);
   }
 
@@ -246,7 +246,7 @@ public boolean equal(A a1, A a2) {
    * An equal instance for the {@link StringBuffer} type.
    */
   public static final Equal<StringBuffer> stringBufferEqual =
-      equalAltDef((sb1, sb2) -> {
+      equalDef((sb1, sb2) -> {
         if (sb1.length() == sb2.length()) {
           for (int i = 0; i < sb1.length(); i++)
             if (sb1.charAt(i) != sb2.charAt(i))
@@ -260,7 +260,7 @@ public boolean equal(A a1, A a2) {
    * An equal instance for the {@link StringBuilder} type.
    */
   public static final Equal<StringBuilder> stringBuilderEqual =
-      equalAltDef((sb1, sb2) -> {
+      equalDef((sb1, sb2) -> {
         if (sb1.length() == sb2.length()) {
           for (int i = 0; i < sb1.length(); i++)
             if (sb1.charAt(i) != sb2.charAt(i))
@@ -305,7 +305,7 @@ public static <A, B> Equal<Validation<A, B>> validationEqual(final Equal<A> ea,
    */
   public static <A> Equal<List<A>> listEqual(final Equal<A> ea) {
     Definition<A> eaDef = ea.def;
-    return equalAltDef((a1, a2) -> {
+    return equalDef((a1, a2) -> {
       List<A> x1 = a1;
       List<A> x2 = a2;
 
@@ -357,7 +357,7 @@ public static <A> Equal<Seq<A>> seqEqual(final Equal<A> e) {
    */
   public static <A> Equal<Stream<A>> streamEqual(final Equal<A> ea) {
     Definition<A> eaDef = ea.def;
-    return equalAltDef((a1, a2) -> {
+    return equalDef((a1, a2) -> {
       Stream<A> x1 = a1;
       Stream<A> x2 = a2;
 
@@ -381,7 +381,7 @@ public static <A> Equal<Stream<A>> streamEqual(final Equal<A> ea) {
    */
   public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
     Definition<A> eaDef = ea.def;
-    return equalAltDef((a1, a2) -> {
+    return equalDef((a1, a2) -> {
       if (a1.length() == a2.length()) {
         for (int i = 0; i < a1.length(); i++) {
           if (!eaDef.equal(a1.get(i), a2.get(i)))
@@ -400,7 +400,18 @@ public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
    * @return An equal instance for the {@link Tree} type.
    */
   public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
-    return equalAltDef((t1, t2) -> ea.eq(t1.root(), t2.root()) && p1Equal(streamEqual(treeEqual(ea))).eq(t2.subForest(), t1.subForest()));
+    Definition<A> eaDef = ea.def;
+    return equalDef(new AlternateDefinition<Tree<A>>() {
+
+      final Definition<P1<Stream<Tree<A>>>> subForestEqDef = p1Equal(streamEqual(equalDef(this))).def;
+
+      @Override
+      public boolean equal(Tree<A> t1, Tree<A> t2) {
+        return eaDef.equal(t1.root(), t2.root())
+            && subForestEqDef.equal(t1.subForest(), t2.subForest());
+
+      }
+    });
   }
 
   /**
@@ -410,7 +421,7 @@ public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
    * @return An equal instance for a product-1.
    */
   public static <A> Equal<P1<A>> p1Equal(final Equal<A> ea) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()));
+    return ea.contramap(P1.__1());
   }
 
   /**
@@ -421,7 +432,9 @@ public static <A> Equal<P1<A>> p1Equal(final Equal<A> ea) {
    * @return An equal instance for a product-2.
    */
   public static <A, B> Equal<P2<A, B>> p2Equal(final Equal<A> ea, final Equal<B> eb) {
-    return equalAltDef((p1, p2)-> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    return equalDef((p1, p2)-> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()));
   }
 
   /**
@@ -433,7 +446,10 @@ public static <A, B> Equal<P2<A, B>> p2Equal(final Equal<A> ea, final Equal<B> e
    * @return An equal instance for a product-3.
    */
   public static <A, B, C> Equal<P3<A, B, C>> p3Equal(final Equal<A> ea, final Equal<B> eb, final Equal<C> ec) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()));
   }
 
   /**
@@ -447,8 +463,12 @@ public static <A, B, C> Equal<P3<A, B, C>> p3Equal(final Equal<A> ea, final Equa
    */
   public static <A, B, C, D> Equal<P4<A, B, C, D>> p4Equal(final Equal<A> ea, final Equal<B> eb, final Equal<C> ec,
                                                            final Equal<D> ed) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
-           ed.eq(p1._4(), p2._4()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    Definition<D> edDef = ed.def;
+    return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
+        edDef.equal(p1._4(), p2._4()));
   }
 
   /**
@@ -464,8 +484,13 @@ public static <A, B, C, D> Equal<P4<A, B, C, D>> p4Equal(final Equal<A> ea, fina
   public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea, final Equal<B> eb,
                                                                  final Equal<C> ec, final Equal<D> ed,
                                                                  final Equal<E> ee) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
-           ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    Definition<D> edDef = ed.def;
+    Definition<E> eeDef = ee.def;
+    return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
+        edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()));
   }
 
   /**
@@ -482,8 +507,14 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
   public static <A, B, C, D, E, F$> Equal<P6<A, B, C, D, E, F$>> p6Equal(final Equal<A> ea, final Equal<B> eb,
                                                                          final Equal<C> ec, final Equal<D> ed,
                                                                          final Equal<E> ee, final Equal<F$> ef) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
-           ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    Definition<D> edDef = ed.def;
+    Definition<E> eeDef = ee.def;
+    Definition<F$> efDef = ef.def;
+    return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
+        edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()));
   }
 
   /**
@@ -502,9 +533,16 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
                                                                                final Equal<C> ec, final Equal<D> ed,
                                                                                final Equal<E> ee, final Equal<F$> ef,
                                                                                final Equal<G> eg) {
-    return equalAltDef((p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
-           ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()) &&
-           eg.eq(p1._7(), p2._7()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    Definition<D> edDef = ed.def;
+    Definition<E> eeDef = ee.def;
+    Definition<F$> efDef = ef.def;
+    Definition<G> egDef = eg.def;
+    return equalDef((p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
+        edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()) &&
+        egDef.equal(p1._7(), p2._7()));
   }
 
   /**
@@ -528,10 +566,18 @@ public static <A, B, C, D, E> Equal<P5<A, B, C, D, E>> p5Equal(final Equal<A> ea
                                                                                      final Equal<F$> ef,
                                                                                      final Equal<G> eg,
                                                                                      final Equal<H> eh) {
-    return equalAltDef(
-        (p1, p2) -> ea.eq(p1._1(), p2._1()) && eb.eq(p1._2(), p2._2()) && ec.eq(p1._3(), p2._3()) &&
-                   ed.eq(p1._4(), p2._4()) && ee.eq(p1._5(), p2._5()) && ef.eq(p1._6(), p2._6()) &&
-                   eg.eq(p1._7(), p2._7()) && eh.eq(p1._8(), p2._8()));
+    Definition<A> eaDef = ea.def;
+    Definition<B> ebDef = eb.def;
+    Definition<C> ecDef = ec.def;
+    Definition<D> edDef = ed.def;
+    Definition<E> eeDef = ee.def;
+    Definition<F$> efDef = ef.def;
+    Definition<G> egDef = eg.def;
+    Definition<H> ehDef = eh.def;
+    return equalDef(
+        (p1, p2) -> eaDef.equal(p1._1(), p2._1()) && ebDef.equal(p1._2(), p2._2()) && ecDef.equal(p1._3(), p2._3()) &&
+            edDef.equal(p1._4(), p2._4()) && eeDef.equal(p1._5(), p2._5()) && efDef.equal(p1._6(), p2._6()) &&
+            egDef.equal(p1._7(), p2._7()) && ehDef.equal(p1._8(), p2._8()));
   }
 
   /**
@@ -622,7 +668,9 @@ public static <A> Equal<V8<A>> v8Equal(final Equal<A> ea) {
    * @return an equal instance for a heterogeneous list.
    */
   public static <E, L extends HList<L>> Equal<HList.HCons<E, L>> hListEqual(final Equal<E> e, final Equal<L> l) {
-    return equal(curry((HList.HCons<E, L> c1, HList.HCons<E, L> c2) -> e.eq(c1.head(), c2.head()) && l.eq(c1.tail(), c2.tail())));
+    Definition<E> eDef = e.def;
+    Definition<L> lDef = l.def;
+    return equalDef((c1, c2) -> eDef.equal(c1.head(), c2.head()) && lDef.equal(c1.tail(), c2.tail()));
   }
 
   /**
@@ -632,15 +680,15 @@ public static <E, L extends HList<L>> Equal<HList.HCons<E, L>> hListEqual(final
    * @return An equal instance for sets.
    */
   public static <A> Equal<Set<A>> setEqual(final Equal<A> e) {
-    return equal(curry((Set<A> a, Set<A> b) -> streamEqual(e).eq(a.toStream(), b.toStream())));
+    return streamEqual(e).contramap(Set::toStream);
   }
 
   public static <K, V> Equal<TreeMap<K, V>> treeMapEqual(Equal<K> k, Equal<V> v) {
-    return equal(t1 -> t2 -> streamEqual(p2Equal(k, v)).eq(t1.toStream(), t2.toStream()));
+    return streamEqual(p2Equal(k, v)).contramap(TreeMap::toStream);
   }
 
   public static <A, B> Equal<Writer<A, B>> writerEqual(Equal<A> eq1, Equal<B> eq2) {
-    return equal(w1 -> w2 -> p2Equal(eq1, eq2).eq(w1.run(), w2.run()));
+    return p2Equal(eq1, eq2).contramap(Writer::run);
   }
   
   /**

From 7ee7a49c2460fac22cf413afa346036031d2277e Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Wed, 22 Jun 2016 21:06:09 +0200
Subject: [PATCH 116/336] Implement either catamorphism with method dispatch 
 avoiding creation of Left/Right projections.  Also some minor cleanup and
 refactoring  to make more use of catamorphism.

---
 core/src/main/java/fj/data/Either.java | 113 +++++++++++++------------
 1 file changed, 59 insertions(+), 54 deletions(-)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index a4f0fc02..ebfe3b2c 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -1,24 +1,29 @@
 package fj.data;
 
-import static fj.Bottom.error;
+import fj.Equal;
+import fj.F;
+import fj.F0;
+import fj.Function;
+import fj.Hash;
+import fj.P1;
+import fj.Show;
+import fj.Unit;
+import fj.function.Effect1;
 
-import fj.*;
+import java.util.Collection;
+import java.util.Iterator;
 
+import static fj.Bottom.error;
+import static fj.Function.compose;
 import static fj.Function.identity;
 import static fj.P.p;
-
-import fj.function.Effect1;
-
 import static fj.Unit.unit;
 import static fj.data.Array.mkArray;
+import static fj.data.List.cons_;
 import static fj.data.List.list;
 import static fj.data.List.single;
-import static fj.data.List.cons_;
 import static fj.data.Option.some;
 
-import java.util.Collection;
-import java.util.Iterator;
-
 /**
  * The <code>Either</code> type represents a value of one of two possible types (a disjoint union).
  * The data constructors; <code>Left</code> and <code>Right</code> represent the two possible
@@ -72,11 +77,7 @@ public final RightProjection<A, B> right() {
    * @param right The function to call if this is right.
    * @return The reduced value.
    */
-  public final <X> X either(final F<A, X> left, final F<B, X> right) {
-    return isLeft() ?
-           left.f(left().value()) :
-           right.f(right().value());
-  }
+  public abstract <X> X either(final F<A, X> left, final F<B, X> right);
 
   /**
    * Map the given functions across the appropriate side.
@@ -86,9 +87,7 @@ public final <X> X either(final F<A, X> left, final F<B, X> right) {
    * @return A new either value after mapping with the appropriate function applied.
    */
   public final <X, Y> Either<X, Y> bimap(final F<A, X> left, final F<B, Y> right) {
-    return isLeft() ?
-           left(left.f(left().value())) :
-           right(right.f(right().value()));
+    return either(compose(left_(), left), compose(right_(), right));
   }
 
   @Override
@@ -107,7 +106,7 @@ public final int hashCode() {
    * @return The value of this either swapped to the opposing side.
    */
   public final Either<B, A> swap() {
-    return isLeft() ? new Right<>(((Left<A, B>) this).a) : new Left<>(((Right<A, B>) this).b);
+    return either(right_(), left_());
   }
 
   private static final class Left<A, B> extends Either<A, B> {
@@ -124,6 +123,11 @@ public boolean isLeft() {
     public boolean isRight() {
       return false;
     }
+
+    @Override
+    public <X> X either(F<A, X> left, F<B, X> right) {
+      return left.f(a);
+    }
   }
 
   private static final class Right<A, B> extends Either<A, B> {
@@ -140,6 +144,11 @@ public boolean isLeft() {
     public boolean isRight() {
       return true;
     }
+
+    @Override
+    public <X> X either(F<A, X> left, F<B, X> right) {
+      return right.f(b);
+    }
   }
 
   /**
@@ -414,17 +423,17 @@ public Collection<A> toCollection() {
       return toList().toCollection();
     }
 
-   public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
+    public <C> Option<Either<C,B>> traverseOption(F<A, Option<C>> f) {
        return e.isLeft() ?
-               f.f(value()).map(Either::<C, B>left) :
-               some(Either.right(e.right().value()));
-   }
+               f.f(value()).map(left_()) :
+               some(right(e.right().value()));
+    }
 
-  public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
-      return e.isLeft() ?
-              f.f(value()).map(Either::<C, B>left) :
-              Stream.single(Either.right(e.right().value()));
-  }
+    public <C> Stream<Either<C, B>> traverseStream(F<A, Stream<C>> f) {
+        return e.isLeft() ?
+                f.f(value()).map(left_()) :
+                Stream.single(right(e.right().value()));
+    }
   }
 
   /**
@@ -543,7 +552,6 @@ public <X> Either<A, X> bind(final F<B, Either<A, X>> f) {
       return e.isRight() ? f.f(value()) : new Left<>(e.left().value());
     }
 
-
     /**
      * Anonymous bind through this projection.
      *
@@ -553,17 +561,18 @@ public <X> Either<A, X> bind(final F<B, Either<A, X>> f) {
     public <X> Either<A, X> sequence(final Either<A, X> e) {
       return bind(Function.constant(e));
     }
+
     /**
-       * Traverse with function that produces List (non-determinism).
-       *
-       * @param f the function to traverse with
-       * @return An either after traversing through this projection.
-    */
-      public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
-          return e.isRight() ?
-                  f.f(value()).map(Either::right) :
-                  list(left(e.left().value()));
-      }
+     * Traverse with function that produces List (non-determinism).
+     *
+     * @param f the function to traverse with
+     * @return An either after traversing through this projection.
+     */
+    public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
+        return e.isRight() ?
+                f.f(value()).map(right_()) :
+                list(left(e.left().value()));
+    }
 
       /**
        * Traverse with a function that has IO effect
@@ -573,19 +582,19 @@ public <C> List<Either<A, C>> traverseList(final F<B, List<C>> f) {
        */
       public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
           return e.isRight() ?
-                  IOFunctions.map(f.f(value()), Either::<A, C>right) :
+                  IOFunctions.map(f.f(value()), right_()) :
                   IOFunctions.lazy(() -> left(e.left().value()));
       }
 
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
           return e.isRight() ?
-                  f.f(value()).map(Either::<A, C>right) :
+                  f.f(value()).map(right_()) :
                   p(left(e.left().value()));
       }
 
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
           return e.isRight() ?
-                  f.f(value()).map(Either::<A, C>right) :
+                  f.f(value()).map(right_()) :
                   some(left(e.left().value()));
       }
 
@@ -758,8 +767,7 @@ public static <A, B, X> F<F<B, X>, F<Either<A, B>, Either<A, X>>> rightMap_() {
    * @return An either after joining.
    */
   public static <A, B> Either<A, B> joinLeft(final Either<Either<A, B>, B> e) {
-    final F<Either<A, B>, Either<A, B>> id = identity();
-    return e.left().bind(id);
+    return e.left().bind(identity());
   }
 
   /**
@@ -769,8 +777,7 @@ public static <A, B> Either<A, B> joinLeft(final Either<Either<A, B>, B> e) {
    * @return An either after joining.
    */
   public static <A, B> Either<A, B> joinRight(final Either<A, Either<A, B>> e) {
-    final F<Either<A, B>, Either<A, B>> id = identity();
-    return e.right().bind(id);
+    return e.right().bind(identity());
   }
 
   /**
@@ -781,7 +788,7 @@ public static <A, B> Either<A, B> joinRight(final Either<A, Either<A, B>> e) {
    */
   public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a) {
     return a.isEmpty() ?
-           Either.left(List.nil()) :
+           left(List.nil()) :
            a.head().left().bind(aa -> sequenceLeft(a.tail()).left().map(cons_(aa)));
   }
 
@@ -793,7 +800,7 @@ public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a)
    */
   public static <B, X> Either<X, List<B>> sequenceRight(final List<Either<X, B>> a) {
     return a.isEmpty() ?
-           Either.right(List.nil()) :
+           right(List.nil()) :
            a.head().right().bind(bb -> sequenceRight(a.tail()).right().map(cons_(bb)));
   }
 
@@ -807,10 +814,10 @@ public final <C> List<Either<A, C>> traverseListRight(final F<B, List<C>> f) {
   }
 
   /**
-     * Traversable instance of LeftProjection of Either for List.
-     *
-     * @return traversed value
-  */
+   * Traversable instance of LeftProjection of Either for List.
+   *
+   * @return traversed value
+   */
     public final <C> List<Either<C, B>> traverseListLeft(final F<A, List<C>> f) {
         return left().traverseList(f);
     }
@@ -869,8 +876,6 @@ public final <C> Stream<Either<C, B>> traverseStreamLeft(final F<A, Stream<C>> f
     return left().traverseStream(f);
   }
 
-
-
   /**
    * Takes an <code>Either</code> to its contained value within left or right.
    *
@@ -878,7 +883,7 @@ public final <C> Stream<Either<C, B>> traverseStreamLeft(final F<A, Stream<C>> f
    * @return An <code>Either</code> to its contained value within left or right.
    */
   public static <A> A reduce(final Either<A, A> e) {
-    return e.isLeft() ? e.left().value() : e.right().value();
+    return e.either(identity(), identity());
   }
 
   /**

From 2aa3878bf8e803232da57788b75a055a9859606a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Wed, 22 Jun 2016 21:25:24 +0200
Subject: [PATCH 117/336] Definition interfaces should be public

---
 core/src/main/java/fj/Equal.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index e5b2ebb1..1db2c492 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -40,7 +40,7 @@ public final class Equal<A> {
   /**
    * Primitives functions of Equal: minimal definition and overridable methods.
    */
-  interface Definition<A> {
+  public interface Definition<A> {
 
     F<A, Boolean> equal(A a);
 
@@ -52,7 +52,7 @@ default boolean equal(A a1, A a2) {
   /**
    * Primitives functions of Equal: alternative minimal definition and overridable methods.
    */
-  interface AlternateDefinition<A> extends Definition<A> {
+  public interface AlternateDefinition<A> extends Definition<A> {
 
     @Override
     boolean equal(A a1, A a2);

From 1c94e087fd35abe6f2224e1165183d065f6a9fc8 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Wed, 22 Jun 2016 21:52:16 +0200
Subject: [PATCH 118/336] Initial refactoring of Ord to use Definition
 interface

---
 core/src/main/java/fj/Ord.java | 166 +++++++++++++++++++++++++--------
 1 file changed, 126 insertions(+), 40 deletions(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 04cc46b9..a2ffb7ca 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -16,6 +16,7 @@
 
 import static fj.Function.apply;
 import static fj.Function.compose;
+import static fj.Function.compose2;
 import static fj.Function.curry;
 import static fj.Semigroup.semigroup;
 
@@ -25,12 +26,49 @@
  * @version %build.number%
  */
 public final class Ord<A> {
-  private final F<A, F<A, Ordering>> f;
 
-  private Ord(final F<A, F<A, Ordering>> f) {
-    this.f = f;
-    this.max = a1 -> apply((a2, o) -> o == Ordering.GT ? a1 : a2, f.f(a1));
-    this.min = a1 -> apply((a2, o) -> o == Ordering.LT ? a1 : a2, f.f(a1));
+  /**
+   * Primitives functions of Ord: minimal definition and overridable methods.
+   */
+  public interface Definition<A> extends Equal.Definition<A> {
+
+    F<A, Ordering> compare(A a);
+
+    default Ordering compare(A a1, A a2) {
+      return compare(a1).f(a2);
+    }
+
+    @Override
+    default boolean equal(A a1, A a2) {
+      return compare(a1, a2) == Ordering.EQ;
+    }
+
+    @Override
+    default F<A, Boolean> equal(A a) {
+      return compose(o -> o == Ordering.EQ, compare(a));
+    }
+  }
+
+  /**
+   * Primitives functions of Ord: alternative minimal definition and overridable methods.
+   */
+  public interface AlternateDefinition<A> extends Definition<A> {
+
+    Ordering compare(A a1, A a2);
+
+    default F<A, Ordering> compare(A a1) {
+      return a2 -> compare(a1, a2);
+    }
+
+  }
+
+
+  private final Definition<A> def;
+
+  private Ord(final Definition<A> def) {
+    this.def = def;
+    this.max = a1 -> apply((a2, o) -> o == Ordering.GT ? a1 : a2, def.compare(a1));
+    this.min = a1 -> apply((a2, o) -> o == Ordering.LT ? a1 : a2, def.compare(a1));
   }
 
   /**
@@ -39,7 +77,7 @@ private Ord(final F<A, F<A, Ordering>> f) {
    * @return A function that returns an ordering for its arguments.
    */
   public F<A, F<A, Ordering>> compare() {
-    return f;
+    return def::compare;
   }
 
   /**
@@ -50,7 +88,7 @@ public F<A, F<A, Ordering>> compare() {
    * @return An ordering for the given arguments.
    */
   public Ordering compare(final A a1, final A a2) {
-    return f.f(a1).f(a2);
+    return def.compare(a1, a2);
   }
 
   /**
@@ -61,7 +99,7 @@ public Ordering compare(final A a1, final A a2) {
    * @return <code>true</code> if the given arguments are equal, <code>false</code> otherwise.
    */
   public boolean eq(final A a1, final A a2) {
-    return compare(a1, a2) == Ordering.EQ;
+    return def.compare(a1, a2) == Ordering.EQ;
   }
 
   /**
@@ -70,7 +108,7 @@ public boolean eq(final A a1, final A a2) {
    * @return An <code>Equal</code> for this order.
    */
   public Equal<A> equal() {
-    return Equal.equal(a -> compose(o -> o == Ordering.EQ, f.f(a)));
+    return Equal.equalDef(def);
   }
 
   /**
@@ -80,7 +118,18 @@ public Equal<A> equal() {
    * @return A new ord.
    */
   public <B> Ord<B> contramap(final F<B, A> f) {
-    return ord(F1Functions.o(F1Functions.o(F1Functions.andThen(f), this.f), f));
+    Definition<A> selfDef = def;
+    return ordDef(new Definition<B>() {
+      @Override
+      public F<B, Ordering> compare(B b) {
+        return compose(selfDef.compare(f.f(b)), f);
+      }
+
+      @Override
+      public Ordering compare(B b1, B b2) {
+        return selfDef.compare(f.f(b1), f.f(b2));
+      }
+    });
   }
 
   /**
@@ -93,7 +142,7 @@ public <B> Ord<B> contramap(final F<B, A> f) {
    *         <code>false</code> otherwise.
    */
   public boolean isLessThan(final A a1, final A a2) {
-    return compare(a1, a2) == Ordering.LT;
+    return def.compare(a1, a2) == Ordering.LT;
   }
 
     /**
@@ -106,7 +155,7 @@ public boolean isLessThan(final A a1, final A a2) {
      *         <code>false</code> otherwise.
      */
     public boolean isLessThanOrEqualTo(final A a1, final A a2) {
-        return compare(a1, a2) != Ordering.GT;
+        return def.compare(a1, a2) != Ordering.GT;
     }
 
   /**
@@ -119,7 +168,7 @@ public boolean isLessThanOrEqualTo(final A a1, final A a2) {
    *         argument, <code>false</code> otherwise.
    */
   public boolean isGreaterThan(final A a1, final A a2) {
-    return compare(a1, a2) == Ordering.GT;
+    return def.compare(a1, a2) == Ordering.GT;
   }
 
   /**
@@ -129,7 +178,7 @@ public boolean isGreaterThan(final A a1, final A a2) {
    * @return A function that returns true if its argument is less than the argument to this method.
    */
   public F<A, Boolean> isLessThan(final A a) {
-    return compose(o -> o != Ordering.LT, f.f(a));
+    return compose(o -> o != Ordering.LT, def.compare(a));
   }
 
   /**
@@ -139,7 +188,7 @@ public F<A, Boolean> isLessThan(final A a) {
    * @return A function that returns true if its argument is greater than the argument to this method.
    */
   public F<A, Boolean> isGreaterThan(final A a) {
-    return compose(o -> o != Ordering.GT, f.f(a));
+    return compose(o -> o != Ordering.GT, def.compare(a));
   }
 
   /**
@@ -183,7 +232,20 @@ public final Semigroup<A> maxSemigroup() {
       return semigroup(max);
   }
 
-  public final Ord<A> reverse() { return ord(Function.flip(f)); }
+  public final Ord<A> reverse() {
+    Definition<A> selfDef = def;
+    return ordDef(new Definition<A>() {
+      @Override
+      public F<A, Ordering> compare(A a) {
+        return compose(Ordering::reverse, selfDef.compare(a));
+      }
+
+      @Override
+      public Ordering compare(A a1, A a2) {
+        return selfDef.compare(a2, a1);
+      }
+    });
+  }
 
   /**
    * Returns an order instance that uses the given equality test and ordering function.
@@ -192,9 +254,30 @@ public final Semigroup<A> maxSemigroup() {
    * @return An order instance.
    */
   public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
-    return new Ord<>(f);
+    return new Ord<>(f::f);
   }
 
+  /**
+   * Returns an order instance that uses the given minimal equality test and ordering definiion.
+   *
+   * @param def The order definition.
+   * @return An order instance.
+   */
+  public static <A> Ord<A> ordDef(final Definition<A> def) {
+    return new Ord<>(def);
+  }
+
+  /**
+   * Returns an order instance that uses the given minimal equality test and ordering definiion.
+   *
+   * @param def The order definition.
+   * @return An order instance.
+   */
+  public static <A> Ord<A> ordDef(final AlternateDefinition<A> def) {
+    return new Ord<>(def);
+  }
+
+
   /**
    * An order instance for the <code>boolean</code> type.
    */
@@ -248,7 +331,7 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
   /**
    * An order instance for the {@link Ordering} type.
    */
-  public static final Ord<Ordering> orderingOrd = Ord.ord(curry((o1, o2) -> o1 == o2 ?
+  public static final Ord<Ordering> orderingOrd = ordDef((o1, o2) -> o1 == o2 ?
          Ordering.EQ :
          o1 == Ordering.LT ?
          Ordering.LT :
@@ -256,7 +339,7 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
          Ordering.GT :
          o1 == Ordering.EQ ?
          Ordering.LT :
-         Ordering.GT));
+         Ordering.GT);
 
   /**
    * An order instance for the {@link String} type.
@@ -280,13 +363,14 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
    * @return An order instance for the {@link Option} type.
    */
   public static <A> Ord<Option<A>> optionOrd(final Ord<A> oa) {
-    return ord(o1 -> o2 -> o1.isNone() ?
+    Definition<A> oaDef = oa.def;
+    return ordDef((o1, o2) -> o1.isNone() ?
             o2.isNone() ?
                     Ordering.EQ :
                     Ordering.LT :
             o2.isNone() ?
                     Ordering.GT :
-                    oa.f.f(o1.some()).f(o2.some()));
+                oaDef.compare(o1.some()).f(o2.some()));
   }
 
   /**
@@ -297,13 +381,15 @@ public static <A> Ord<Option<A>> optionOrd(final Ord<A> oa) {
    * @return An order instance for the {@link Either} type.
    */
   public static <A, B> Ord<Either<A, B>> eitherOrd(final Ord<A> oa, final Ord<B> ob) {
-    return ord(e1 -> e2 -> e1.isLeft() ?
+    Definition<A> oaDef = oa.def;
+    Definition<B> obDef = ob.def;
+    return ordDef((e1, e2) -> e1.isLeft() ?
             e2.isLeft() ?
-                    oa.f.f(e1.left().value()).f(e2.left().value()) :
-                    Ordering.LT :
+                oaDef.compare(e1.left().value()).f(e2.left().value()) :
+                Ordering.LT :
             e2.isLeft() ?
-                    Ordering.GT :
-                    ob.f.f(e1.right().value()).f(e2.right().value()));
+                Ordering.GT :
+                obDef.compare(e1.right().value()).f(e2.right().value()));
   }
 
   /**
@@ -324,7 +410,7 @@ public static <A, B> Ord<Validation<A, B>> validationOrd(final Ord<A> oa, final
    * @return An order instance for the {@link List} type.
    */
   public static <A> Ord<List<A>> listOrd(final Ord<A> oa) {
-    return ord(l1 -> l2 -> {
+    return ordDef((l1, l2) -> {
       List<A> x1 = l1;
       List<A> x2 = l2;
 
@@ -364,14 +450,15 @@ public static <A> Ord<NonEmptyList<A>> nonEmptyListOrd(final Ord<A> oa) {
    * @return An order instance for the {@link Stream} type.
    */
   public static <A> Ord<Stream<A>> streamOrd(final Ord<A> oa) {
-    return ord(s1 -> s2 -> {
+    return ordDef((s1, s2) -> {
         if (s1.isEmpty())
             return s2.isEmpty() ? Ordering.EQ : Ordering.LT;
         else if (s2.isEmpty())
             return s1.isEmpty() ? Ordering.EQ : Ordering.GT;
         else {
             final Ordering c = oa.compare(s1.head(), s2.head());
-            return c == Ordering.EQ ? streamOrd(oa).f.f(s1.tail()._1()).f(s2.tail()._1()) : c;
+          // FIXME: not stack safe
+            return c == Ordering.EQ ? streamOrd(oa).def.compare(s1.tail()._1()).f(s2.tail()._1()) : c;
         }
     });
   }
@@ -383,7 +470,7 @@ else if (s2.isEmpty())
    * @return An order instance for the {@link Array} type.
    */
   public static <A> Ord<Array<A>> arrayOrd(final Ord<A> oa) {
-    return ord(a1 -> a2 -> {
+    return ordDef((a1, a2) -> {
         int i = 0;
         //noinspection ForLoopWithMissingComponent
         for (; i < a1.length() && i < a2.length(); i++) {
@@ -414,7 +501,7 @@ public static <A> Ord<Set<A>> setOrd(final Ord<A> oa) {
   /**
    * An order instance for the {@link Unit} type.
    */
-  public static final Ord<Unit> unitOrd = ord(curry((Unit u1, Unit u2) -> Ordering.EQ));
+  public static final Ord<Unit> unitOrd = ordDef((u1, u2) -> Ordering.EQ);
 
   /**
    * An order instance for a product-1.
@@ -435,15 +522,15 @@ public static <A> Ord<P1<A>> p1Ord(final Ord<A> oa) {
    * @return An order instance for a product-2, with the first factor considered most significant.
    */
   public static <A, B> Ord<P2<A, B>> p2Ord(final Ord<A> oa, final Ord<B> ob) {
-    return ord(curry((P2<A, B> a, P2<A, B> b) -> oa.eq(a._1(), b._1()) ? ob.compare(a._2(), b._2()) : oa.compare(a._1(), b._1())));
+    return ordDef((a, b) -> oa.eq(a._1(), b._1()) ? ob.compare(a._2(), b._2()) : oa.compare(a._1(), b._1()));
   }
 
     public static <A, B> Ord<P2<A, B>> p2Ord1(Ord<A> oa) {
-        return ord(p1 -> p2 -> oa.compare(p1._1(), p2._1()));
+        return ordDef((p1, p2) -> oa.compare(p1._1(), p2._1()));
     }
 
     public static <A, B> Ord<P2<A, B>> p2Ord2(Ord<B> ob) {
-        return ord(p1 -> p2 -> ob.compare(p1._2(), p2._2()));
+        return ordDef((p1, p2) -> ob.compare(p1._2(), p2._2()));
     }
 
   /**
@@ -455,9 +542,9 @@ public static <A, B> Ord<P2<A, B>> p2Ord2(Ord<B> ob) {
    * @return An order instance for a product-3, with the first factor considered most significant.
    */
   public static <A, B, C> Ord<P3<A, B, C>> p3Ord(final Ord<A> oa, final Ord<B> ob, final Ord<C> oc) {
-    return ord(curry((P3<A, B, C> a, P3<A, B, C> b) -> oa.eq(a._1(), b._1()) ?
+    return ordDef((a, b) -> oa.eq(a._1(), b._1()) ?
            p2Ord(ob, oc).compare(P.p(a._2(), a._3()), P.p(b._2(), b._3()))
-                                 : oa.compare(a._1(), b._1())));
+                                 : oa.compare(a._1(), b._1()));
   }
 
   /**
@@ -472,8 +559,7 @@ public static <A, B, C> Ord<P3<A, B, C>> p3Ord(final Ord<A> oa, final Ord<B> ob,
    * @return An order instance for the <code>Comparable</code> interface.
    */
   public static <A extends Comparable<A>> Ord<A> comparableOrd() {
-
-    return ord(a1 -> a2 -> Ordering.fromInt(a1.compareTo(a2)));
+    return ordDef((a1, a2) -> Ordering.fromInt(a1.compareTo(a2)));
   }
 
   /**
@@ -485,7 +571,7 @@ public static <A extends Comparable<A>> Ord<A> comparableOrd() {
    * @see #hashEqualsOrd()
    */
   public static <A> Ord<A> hashOrd() {
-    return ord(a -> {
+    return ordDef(a -> {
       int aHash = a.hashCode();
       return a2 -> Ordering.fromInt(Integer.compare(aHash, a2.hashCode()));
     });
@@ -499,7 +585,7 @@ public static <A> Ord<A> hashOrd() {
    * @return An order instance that is based on {@link Object#hashCode()} and {@link Object#equals}.
    */
   public static <A> Ord<A> hashEqualsOrd() {
-    return ord(a -> {
+    return ordDef(a -> {
       int aHash = a.hashCode();
       return a2 -> {
         final int a2Hash = a2.hashCode();

From f040341840ea037a851326c5b3d43cf6d1ac0cb8 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:29:33 +0200
Subject: [PATCH 119/336] Add first class either catamorphism

---
 core/src/main/java/fj/data/Either.java | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index a4f0fc02..c0c143af 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -737,6 +737,17 @@ public static <A, B> Either<A, B> right(final B b) {
     return new Right<>(b);
   }
 
+  /**
+   * First class catamorphism for either. Folds over this either breaking into left or right.
+   *
+   * @param left  The function to call if this is left.
+   * @param right The function to call if this is right.
+   * @return The reducing function.
+   */
+  public static <A, B, X> F<Either<A,B>, X> cata(final F<A, X> left, final F<B, X> right) {
+    return e -> e.either(left, right);
+  }
+
   /**
    * @return A function that maps another function across an either's left projection.
    */

From 59e35fa9d69a2154211516086bf28330baa26c34 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 21 Jun 2016 22:54:48 +0200
Subject: [PATCH 120/336] Add first class option catamorphism

---
 core/src/main/java/fj/data/Option.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 4cdb411f..f1b228d0 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -688,6 +688,18 @@ public static <T> F<T, Option<T>> fromNull() {
     return Option::fromNull;
   }
 
+  /**
+   * First-class catamorphism for Option: return a function that will performs
+   * a reduction on an optional value using the given arguments.
+   *
+   * @param none The value to return if this optional value has no value.
+   * @param some The function to apply to the value of this optional value.
+   * @return the reducing function.
+   */
+  public static final <A, B> F<Option<A>, B> cata(final B none, final F<A, B> some) {
+    return o -> o.option(none, some);
+  }
+
   /**
    * Joins the given optional value of optional value using a bind operation.
    *

From 18690a20a1a634f35ef178204e2cd4f8ee959db2 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Fri, 1 Jul 2016 12:41:23 +0200
Subject: [PATCH 121/336] Use '_' suffix scheme for first class cata of Option
 and Either

---
 core/src/main/java/fj/Equal.java       | 6 +++---
 core/src/main/java/fj/data/Either.java | 2 +-
 core/src/main/java/fj/data/Option.java | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 1db2c492..c743f03e 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -281,8 +281,8 @@ public static <A, B> Equal<Either<A, B>> eitherEqual(final Equal<A> ea, final Eq
     Definition<A> eaDef = ea.def;
     Definition<B> ebDef = eb.def;
     return equalDef(e1 -> e1.either(
-        a1 -> Either.cata(eaDef.equal(a1), (B __) -> false),
-        b1 -> Either.cata((A __)-> false, ebDef.equal(b1))
+        a1 -> Either.either_(eaDef.equal(a1), (B __) -> false),
+        b1 -> Either.either_((A __)-> false, ebDef.equal(b1))
     ));
   }
 
@@ -341,7 +341,7 @@ public static <A> Equal<Option<A>> optionEqual(final Equal<A> ea) {
     Definition<A> eaDef = ea.def;
     return equalDef(o1 -> o1.option(
         Option.isNone_(),
-        a1 -> Option.cata(false, eaDef.equal(a1))
+        a1 -> Option.option_(false, eaDef.equal(a1))
     ));
   }
 
diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index c0c143af..e3e9d5d9 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -744,7 +744,7 @@ public static <A, B> Either<A, B> right(final B b) {
    * @param right The function to call if this is right.
    * @return The reducing function.
    */
-  public static <A, B, X> F<Either<A,B>, X> cata(final F<A, X> left, final F<B, X> right) {
+  public static <A, B, X> F<Either<A,B>, X> either_(final F<A, X> left, final F<B, X> right) {
     return e -> e.either(left, right);
   }
 
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index f1b228d0..54b4bb01 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -696,7 +696,7 @@ public static <T> F<T, Option<T>> fromNull() {
    * @param some The function to apply to the value of this optional value.
    * @return the reducing function.
    */
-  public static final <A, B> F<Option<A>, B> cata(final B none, final F<A, B> some) {
+  public static final <A, B> F<Option<A>, B> option_(final B none, final F<A, B> some) {
     return o -> o.option(none, some);
   }
 

From 9f1cf575b62d8c924538e497b5f7fd8f24845d27 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Fri, 1 Jul 2016 12:41:23 +0200
Subject: [PATCH 122/336] Use '_' suffix scheme for first class cata of Option
 and Either

---
 core/src/main/java/fj/data/Either.java | 2 +-
 core/src/main/java/fj/data/Option.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index c0c143af..e3e9d5d9 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -744,7 +744,7 @@ public static <A, B> Either<A, B> right(final B b) {
    * @param right The function to call if this is right.
    * @return The reducing function.
    */
-  public static <A, B, X> F<Either<A,B>, X> cata(final F<A, X> left, final F<B, X> right) {
+  public static <A, B, X> F<Either<A,B>, X> either_(final F<A, X> left, final F<B, X> right) {
     return e -> e.either(left, right);
   }
 
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index f1b228d0..54b4bb01 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -696,7 +696,7 @@ public static <T> F<T, Option<T>> fromNull() {
    * @param some The function to apply to the value of this optional value.
    * @return the reducing function.
    */
-  public static final <A, B> F<Option<A>, B> cata(final B none, final F<A, B> some) {
+  public static final <A, B> F<Option<A>, B> option_(final B none, final F<A, B> some) {
     return o -> o.option(none, some);
   }
 

From a85308f4a3c2a16e8d5bde7f39a40f68e8f09e4a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 2 Jul 2016 01:02:38 +1000
Subject: [PATCH 123/336] Added release notes for 4.6, added placeholder for
 4.7 release notes

---
 etc/release-notes/release-notes-4.6.adoc | 58 +++++++++++++++++++++---
 etc/release-notes/release-notes-4.7.adoc | 28 ++++++++++++
 2 files changed, 80 insertions(+), 6 deletions(-)
 create mode 100644 etc/release-notes/release-notes-4.7.adoc

diff --git a/etc/release-notes/release-notes-4.6.adoc b/etc/release-notes/release-notes-4.6.adoc
index d9bc2b3d..628457c5 100644
--- a/etc/release-notes/release-notes-4.6.adoc
+++ b/etc/release-notes/release-notes-4.6.adoc
@@ -1,23 +1,60 @@
 
 = Release 4.6
 
-Proposed release: Jun 2016
+Proposed release: June 2016
 
 == Enhancements
 
-* TODO.
+* Added various list permutation generation for Gen (#235).
+* Reduced memory for hard memos (#257).
+* Added a priority queue based on finger trees (#261).
+* Construct a database action from a Connection to a value (#267).
+* Added methods and instances on Natural for Equal, Hash, Arbitrary, Shirnk, equals, hashCode and toString (#274).
+* Use BigIntegers for Natural Gen and Shrink, instead of Long (#278).
+* Various optics for Option (#244).
+* First class catamorphism for Either and Option (#286).
+* Added IO walkthrough (#254).
+* Added numerous Semigroup methods, Monoid.dual, conversion from Ord to Semigroup and NonEmptyList folds (#251).
+* Added ignored Optional optic (#250).
+* Added IO methods: as, voided, when and unless (#245).
+* Added monoid instances for io and unit; added semigroup instances for first, last and io (#246).
 
 == Fixes
 
-* TODO.
+* Fixed Gen.pick (#235).  Affects Gen.variant, Coarbitrary and dependencies.
+* Fixed Rand.reseed (#237).
+* IOFunctions.bracket runs finaliser (#240).
+* Fixed backwards List.traverseIO (#248).
+* Run IOW map, bind and append lazily (#252, 253).
+* Make State class stack safe (#259).
+* Removed extra type parameters in P2.Optic (#273).
+* Fixed BigInteger.shrink (#276, 277).
 
 == Internal
 
-* TODO.
+* Upgrade to Gradle 2.13 (#243).
+* Document version deprecated for all deprecated methods (#264).
+* Fixed various unchecked conversion warnings (#269).
+* Added tests for DbState (#234).
+* Added test for quickcheck Bool (#233).
+* Various improvements (using final classes, method references, diamond operators, type inference, import lists, replace anonymous classes with lambdas etc. - #238).
+* Use Either catamorphism internally (#285).
+* Use uncurried foldLeft as default implementation (#283).
+* Removed workarounds for fixed javac bugs (#282).
+* Added IO test (#272).
+* Exclude the demo subproject from Coveralls code coverage metrics (#268).
+* Added tests for fj.Class (#262).
+* Use method reference in IOWalkthrough (#255).
+* Update retro lambda plugin version from 3.2.0 to 3.2.5 (#247).
 
 == Breaking Changes
 
-* TODO.
+* Removed deprecated Equal.shallowEquals0 (#239).
+* Removed use of Arbitrary wrapper (#271).
+
+== Deprecations
+
+* Array.toJavaArray (#241).
 
 == Documentation
 
@@ -25,4 +62,13 @@ Proposed release: Jun 2016
 
 == Contributors
 
-* TODO.
+* Mark Perry
+* JB Giraudeau
+* @mrbackend
+* Brian McKenna
+* Clinton Selke
+* Gabor Liptak
+* Ryan Johnson
+* Charles O'Farrell
+* Fabian Kramer
+
diff --git a/etc/release-notes/release-notes-4.7.adoc b/etc/release-notes/release-notes-4.7.adoc
new file mode 100644
index 00000000..3c1b265f
--- /dev/null
+++ b/etc/release-notes/release-notes-4.7.adoc
@@ -0,0 +1,28 @@
+
+= Release 4.7
+
+Proposed release: September 2016
+
+== Enhancements
+
+* TODO.
+
+== Fixes
+
+* TODO.
+
+== Internal
+
+* TODO.
+
+== Breaking Changes
+
+* TODO.
+
+== Documentation
+
+* TODO.
+
+== Contributors
+
+* TODO.

From 901f48e82480e0933475ff00565a8ea7bfe9a3c9 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 2 Jul 2016 01:03:18 +1000
Subject: [PATCH 124/336] Added release note process step to go through Github
 issues and pull requests

---
 etc/release-process.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/etc/release-process.txt b/etc/release-process.txt
index f62cb01f..e9bdbb15 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -2,6 +2,8 @@
 Current Release Process
 =======================
 
+Go through the issues and pull requests and set the Label and Milestone field.  Add information to /etc/release-notes/release-notes-<version>.adoc.
+
 Update build.gradle:
 * set isSnapshot to false
 * set useRetroLambda to true

From 1efd9cbe5dd1afa577cff218b1a7a227d4458846 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 2 Jul 2016 01:03:49 +1000
Subject: [PATCH 125/336] Added deprecated release version for remaining
 methods

---
 quickcheck/src/main/java/fj/test/Gen.java  | 5 +++++
 quickcheck/src/main/java/fj/test/Rand.java | 4 +++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 1ea9be0a..1e4a4c5e 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -2,6 +2,7 @@
 
 import fj.F;
 import fj.Function;
+import fj.Ord;
 import fj.P2;
 import fj.Unit;
 import fj.control.Trampoline;
@@ -506,6 +507,8 @@ public static <A> Gen<A> pickOne(List<A> as) {
    * <p>
    * Note: pick is synonymous with combinationOf
    *
+   * @deprecated As of release 4.6, use {@link #combinationOf}
+   *
    * @param n  The number of elements to pick from the given list.
    * @param as The list from which to pick elements.
    * @return A generator of lists that picks the given number of elements from the given list.
@@ -644,6 +647,8 @@ private static <A> Gen<List<A>> pick(Gen<List<Integer>> indexesGen, Array<A> as)
    * <p>
    * Note: someOf is synonymous with someCombinationOf
    *
+   * @deprecated As of release 4.6, use {@link #someCombinationOf}
+   *
    * @param as The list from which to pick values.
    * @return A generator of lists that produces some of the values of the given list.
    */
diff --git a/quickcheck/src/main/java/fj/test/Rand.java b/quickcheck/src/main/java/fj/test/Rand.java
index 97f94596..f1849bb3 100644
--- a/quickcheck/src/main/java/fj/test/Rand.java
+++ b/quickcheck/src/main/java/fj/test/Rand.java
@@ -97,7 +97,9 @@ public Rand reseed(long seed) {
    * result.
    * <p>
    * Calling {@link #reseed(long)} on an instance returned from this method will
-   * result in an exception being thrown. Use {@link #rand(F, F, F)} instead.
+   * result in an exception being thrown.
+   *
+   * @deprecated As of release 4.6, use {@link #rand(F, F, F)}.
    *
    * @param f The integer random generator.
    * @param g The floating-point random generator.

From 4f9083d909d4f8dc40c3bf4eb584c9e0803eef1e Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 2 Jul 2016 01:12:35 +1000
Subject: [PATCH 126/336] Changed 4.6 proposed release date to July 2016

---
 etc/release-notes/release-notes-4.6.adoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/etc/release-notes/release-notes-4.6.adoc b/etc/release-notes/release-notes-4.6.adoc
index 628457c5..756c10e2 100644
--- a/etc/release-notes/release-notes-4.6.adoc
+++ b/etc/release-notes/release-notes-4.6.adoc
@@ -1,7 +1,7 @@
 
 = Release 4.6
 
-Proposed release: June 2016
+Proposed release: July 2016
 
 == Enhancements
 

From d4746a413a00d69572abbf4adb24077a286fc96c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 2 Jul 2016 01:15:12 +1000
Subject: [PATCH 127/336] Added doc section to release notes for 4.6

---
 etc/release-notes/release-notes-4.6.adoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/etc/release-notes/release-notes-4.6.adoc b/etc/release-notes/release-notes-4.6.adoc
index 756c10e2..c67cf8b7 100644
--- a/etc/release-notes/release-notes-4.6.adoc
+++ b/etc/release-notes/release-notes-4.6.adoc
@@ -58,7 +58,7 @@ Proposed release: July 2016
 
 == Documentation
 
-* TODO.
+* Added IO walkthrough (as per enhancements, #254).
 
 == Contributors
 

From 3c5bd85a34ebb2add4e56ad24c7e6b7a92e306cf Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 21:27:23 +1000
Subject: [PATCH 128/336] Do not use method introduced to Java 7
 Integer.compare

---
 core/src/main/java/fj/Ord.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 04cc46b9..4c3ab5c5 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -487,7 +487,7 @@ public static <A extends Comparable<A>> Ord<A> comparableOrd() {
   public static <A> Ord<A> hashOrd() {
     return ord(a -> {
       int aHash = a.hashCode();
-      return a2 -> Ordering.fromInt(Integer.compare(aHash, a2.hashCode()));
+      return a2 -> Ordering.fromInt(Integer.valueOf(aHash).compareTo(a2.hashCode()));
     });
   }
 

From 72289054848eee812add97d31c17bda92e6822af Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 21:28:01 +1000
Subject: [PATCH 129/336] Added first time contributors

---
 etc/CONTRIBUTORS | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/etc/CONTRIBUTORS b/etc/CONTRIBUTORS
index 63be1827..06536883 100644
--- a/etc/CONTRIBUTORS
+++ b/etc/CONTRIBUTORS
@@ -214,3 +214,14 @@ jb@giraudeau.info
 Zheka Kozlov
 @orionll
 
+@mrbackend
+
+Brian McKenna
+
+Clinton Selke
+
+Ryan Johnson
+
+Charles O'Farrell
+
+Fabian Kramer

From 56597e33a0ede3c6a2b3c6647243c3a286c5d223 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 21:28:19 +1000
Subject: [PATCH 130/336] Changes to release 4.6

---
 build.gradle      | 4 ++--
 gradle.properties | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 2744cd00..e11b2274 100644
--- a/build.gradle
+++ b/build.gradle
@@ -48,7 +48,7 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = true
+        isSnapshot = false
         fjBaseVersion = "4.6"
 
         snapshotAppendix = "-SNAPSHOT"
@@ -56,7 +56,7 @@ allprojects {
         fjConsumeVersion = "4.5"
 
         signModule = false
-        useRetroLambda = false
+        useRetroLambda = true
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
diff --git a/gradle.properties b/gradle.properties
index d4552a30..07c2b60c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = false
+signingEnabled = true

From b1796a9c008bb0978eae01b6e4766f35906b0fd8 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 21:48:51 +1000
Subject: [PATCH 131/336] Get ready for 4.7 snapshot

---
 build.gradle      | 8 ++++----
 gradle.properties | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/build.gradle b/build.gradle
index e11b2274..7d9efae1 100644
--- a/build.gradle
+++ b/build.gradle
@@ -48,15 +48,15 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = false
-        fjBaseVersion = "4.6"
+        isSnapshot = true
+        fjBaseVersion = "4.7"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.5"
+        fjConsumeVersion = "4.6"
 
         signModule = false
-        useRetroLambda = true
+        useRetroLambda = false
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
diff --git a/gradle.properties b/gradle.properties
index 07c2b60c..d4552a30 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = true
+signingEnabled = false

From a8584ad52992724e44f6304d74009eea1c6656c8 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 23:01:25 +1000
Subject: [PATCH 132/336] Updated github readme for release 4.6

---
 README.adoc | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/README.adoc b/README.adoc
index 40fec847..9addaff8 100644
--- a/README.adoc
+++ b/README.adoc
@@ -13,7 +13,7 @@ The library is intended for use in production applications and is thoroughly tes
 Functional Java provides abstractions for the following types:
 
 * Basic Data Structures - total and partial functions, products, unit, option, unbiased and right biased unions (either and validation), void.
-* Immutable Collections - array, list, vector, stream, set, map, finger tree, heterogenous list, difference list.
+* Immutable Collections - array, list, vector, stream, set, map, priority queue, finger tree, heterogenous list, difference list.
 * Other Abstractions - monoid, semigroup, natural, random number generator, reader, writer, state, input/output, parser, zipper, specification based testing (quickcheck), actors, optics (lens, prism, fold, traversal and others), concurrency and type conversion.
 
 == URLs
@@ -35,12 +35,12 @@ The Functional Java artifact is published to Maven Central using the group `org.
 * Java 8 specific support (`functionaljava-java8`)
 * property based testing (`functionaljava-quickcheck`)
 
-The latest stable version is `4.5`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `4.6`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.5"
-compile "org.functionaljava:functionaljava-java8:4.5"
-compile "org.functionaljava:functionaljava-quickcheck:4.5"
-compile "org.functionaljava:functionaljava-java-core:4.5"
+compile "org.functionaljava:functionaljava:4.6"
+compile "org.functionaljava:functionaljava-java8:4.6"
+compile "org.functionaljava:functionaljava-quickcheck:4.6"
+compile "org.functionaljava:functionaljava-java-core:4.6"
 ----
 
 and in Maven:
@@ -48,22 +48,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.5</version>
+    <version>4.6</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java8</artifactId>
-    <version>4.5</version>
+    <version>4.6</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.5</version>
+    <version>4.6</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java-core</artifactId>
-    <version>4.5</version>
+    <version>4.6</version>
 </dependency>
 ----
 
@@ -71,7 +71,7 @@ and in Maven:
 
 FunctionalJava uses the Retro Lambda project to backport Java 8 lambdas to Java 6 bytecode.  This requires access to both JDK 6 and 8.  The build system requires the environment variables `JAVA6_HOME` and `JAVA8_HOME` to refer to the appropriate directories.
 
-Building is done using Gradle 2.10.  In the root directory run:
+Building is done using Gradle 2.13.  In the root directory run:
 ----
 ./gradlew
 ----
@@ -100,6 +100,7 @@ A more complete description of the features mentioned above are:
 ** Immutable set implementation using a red/black tree (`fj.data.Set`).
 ** Immutable multi-way tree - aka rose tree (`fj.data.Tree`).
 ** Immutable tree-map using a red/black tree implementation (`fj.data.TreeMap`).
+** Immutable priority queue using finger trees (`fj.data.PriorityQueue`).
 ** Difference lists, a highly performant list.
 * Other Abstractions
 ** Monoid (`fj.Monoid`).

From 8069b9e82161a55ec3fc2c6724d6779315a1072a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 3 Jul 2016 23:34:01 +1000
Subject: [PATCH 133/336] Added 4.6 release date to release notes

---
 etc/release-notes/release-notes-4.6.adoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/etc/release-notes/release-notes-4.6.adoc b/etc/release-notes/release-notes-4.6.adoc
index c67cf8b7..c0d12558 100644
--- a/etc/release-notes/release-notes-4.6.adoc
+++ b/etc/release-notes/release-notes-4.6.adoc
@@ -1,7 +1,7 @@
 
 = Release 4.6
 
-Proposed release: July 2016
+Proposed release: July 3 2016
 
 == Enhancements
 

From 726f0245f7812b2ab42b3e5cf0084523160c8626 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 4 Jul 2016 00:46:41 +1000
Subject: [PATCH 134/336] Modified language in release notes slightly

---
 etc/release-notes/release-notes-4.6.adoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/etc/release-notes/release-notes-4.6.adoc b/etc/release-notes/release-notes-4.6.adoc
index c0d12558..a33c1214 100644
--- a/etc/release-notes/release-notes-4.6.adoc
+++ b/etc/release-notes/release-notes-4.6.adoc
@@ -1,7 +1,7 @@
 
 = Release 4.6
 
-Proposed release: July 3 2016
+Released: 3 July 2016
 
 == Enhancements
 

From 4e369f59032b4c4e695c155aed23b53da9ae4d4c Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 18 Jul 2016 22:05:50 +0200
Subject: [PATCH 135/336] Deprecate unsafe Ord instance and List#groupBy that
 use them.

---
 core/src/main/java/fj/Ord.java                       | 12 +++++++++---
 core/src/main/java/fj/data/List.java                 | 12 ++++++++++--
 demo/src/main/java/fj/demo/List_groupBy.java         |  6 +++---
 .../src/test/scala/fj/data/CheckList.scala           |  2 +-
 .../test/java/fj/data/properties/ListProperties.java |  2 +-
 5 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 4c3ab5c5..5c84c24e 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -478,12 +478,14 @@ public static <A extends Comparable<A>> Ord<A> comparableOrd() {
 
   /**
    * An order instance that uses {@link Object#hashCode()} for computing the order and equality,
-   * thus objects returning the same hashCode are considered to be equals (check {@link #hashEqualsOrd()}
-   * for an additional check on {@link Object#equals(Object)}).
+   * thus objects returning the same hashCode are considered to be equals.
+   * This is not safe and therefore this method is deprecated.
    *
    * @return An order instance that is based on {@link Object#hashCode()}.
-   * @see #hashEqualsOrd()
+   *
+   * @deprecated As of release 4.7.
    */
+  @Deprecated
   public static <A> Ord<A> hashOrd() {
     return ord(a -> {
       int aHash = a.hashCode();
@@ -495,9 +497,13 @@ public static <A> Ord<A> hashOrd() {
    * An order instance that uses {@link Object#hashCode()} and {@link Object#equals} for computing
    * the order and equality. First the hashCode is compared, if this is equal, objects are compared
    * using {@link Object#equals}.
+   * WARNING: This ordering violate antisymmetry on hash collisions.
    *
    * @return An order instance that is based on {@link Object#hashCode()} and {@link Object#equals}.
+   *
+   * @deprecated As of release 4.7.
    */
+  @Deprecated
   public static <A> Ord<A> hashEqualsOrd() {
     return ord(a -> {
       int aHash = a.hashCode();
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index c49fd63a..ac846393 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -1299,11 +1299,15 @@ public final A mode(final Ord<A> o) {
 
   /**
    * Groups the elements of this list by a given keyFunction into a {@link TreeMap}.
-   * The ordering of the keys is determined by {@link fj.Ord#hashOrd()}.
+   * The ordering of the keys is determined by {@link fj.Ord#hashOrd()} (ie. Object#hasCode).
+   * This is not safe and therefore this method is deprecated.
    *
    * @param keyFunction The function to select the keys for the map.
    * @return A TreeMap containing the keys with the accumulated list of matched elements.
+   *
+   * @deprecated As of release 4.7, use {@link #groupBy(F, Ord)}
    */
+  @Deprecated
   public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction) {
     return groupBy(keyFunction, Ord.hashOrd());
   }
@@ -1322,12 +1326,16 @@ public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction, final Or
   /**
    * Groups the elements of this list by a given keyFunction into a {@link TreeMap} and transforms
    * the matching elements with the given valueFunction. The ordering of the keys is determined by
-   * {@link fj.Ord#hashOrd()}.
+   * {@link fj.Ord#hashOrd()} (ie. Object#hasCode).
+   * This is not safe and therefore this method is deprecated.
    *
    * @param keyFunction The function to select the keys for the map.
    * @param valueFunction The function to apply on each matching value.
    * @return A TreeMap containing the keys with the accumulated list of matched and mapped elements.
+   *
+   * @deprecated As of release 4.7, use {@link #groupBy(F, F, Ord)}
    */
+  @Deprecated
   public final <B, C> TreeMap<B, List<C>> groupBy(
       final F<A, B> keyFunction,
       final F<A, C> valueFunction) {
diff --git a/demo/src/main/java/fj/demo/List_groupBy.java b/demo/src/main/java/fj/demo/List_groupBy.java
index f557ec74..b415e19c 100644
--- a/demo/src/main/java/fj/demo/List_groupBy.java
+++ b/demo/src/main/java/fj/demo/List_groupBy.java
@@ -18,7 +18,7 @@ public static void main(final String... args) {
   private static void keyDemo() {
     System.out.println("KeyDemo");
     final List<String> words = list("Hello", "World", "how", "are", "your", "doing");
-    final TreeMap<Integer, List<String>> lengthMap = words.groupBy(String::length);
+    final TreeMap<Integer, List<String>> lengthMap = words.groupBy(String::length, Ord.intOrd);
 
     lengthMap.forEach(entry -> System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2())));
   }
@@ -26,7 +26,7 @@ private static void keyDemo() {
   private static void keyValueDemo() {
     System.out.println("KeyValueDemo");
     final List<Integer> xs = list(1, 2, 3, 4, 5, 6, 7, 8, 9);
-    final TreeMap<Integer, List<String>> result = xs.groupBy(x -> x % 3, Integer::toBinaryString);
+    final TreeMap<Integer, List<String>> result = xs.groupBy(x -> x % 3, Integer::toBinaryString, Ord.intOrd);
 
     result.forEach(entry -> System.out.println(String.format("Numbers with reminder %d are %s", entry._1(), entry._2())));
   }
@@ -35,7 +35,7 @@ private static void keyValueAccDemo() {
     System.out.println("KeyValueAccDemo");
     final List<String> words = list("Hello", "World", "how", "are", "your", "doing");
     final TreeMap<Integer, Integer> lengthCounts =
-        words.groupBy(String::length, Function.identity(), 0, (word, sum) -> sum + 1, Ord.hashOrd());
+        words.groupBy(String::length, Function.identity(), 0, (word, sum) -> sum + 1, Ord.intOrd);
 
     lengthCounts.forEach(entry -> System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2())));
   }
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckList.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckList.scala
index 36bd99f0..d675db81 100644
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckList.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckList.scala
@@ -187,7 +187,7 @@ object CheckList extends Properties("List") {
       join(a)))
 
   property("groupBy") = forAll((a: List[Int]) => {
-    val result = a.groupBy((x: Int) => (x % 2 == 0): lang.Boolean)
+    val result = a.groupBy((x: Int) => (x % 2 == 0): lang.Boolean, Ord.booleanOrd)
     result.get(true).forall((xs: List[Int]) => xs.forall((x: Int) => (x % 2 == 0): lang.Boolean): lang.Boolean) &&
       result.get(false).forall((xs: List[Int]) => xs.forall((x: Int) => (x % 2 != 0): lang.Boolean): lang.Boolean) &&
       a.map((x: Int) => (x % 2) == 0: lang.Boolean).nub().length() == result.size()
diff --git a/props-core/src/test/java/fj/data/properties/ListProperties.java b/props-core/src/test/java/fj/data/properties/ListProperties.java
index 9724488f..fad5f66f 100644
--- a/props-core/src/test/java/fj/data/properties/ListProperties.java
+++ b/props-core/src/test/java/fj/data/properties/ListProperties.java
@@ -255,7 +255,7 @@ public Property nub() {
 
   public Property groupBy() {
     return property(arbList(arbInteger), list -> {
-      final TreeMap<Boolean, List<Integer>> map = list.groupBy(i -> i % 2 == 0);
+      final TreeMap<Boolean, List<Integer>> map = list.groupBy(i -> i % 2 == 0, Ord.booleanOrd);
       final List<Integer> list1 = map.get(true).orSome(nil());
       final List<Integer> list2 = map.get(false).orSome(nil());
       return prop(list.length() == list1.length() + list2.length())

From 10b1c79a02162cb222e3d9de9b118ae2b32e769b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 18 Jul 2016 23:10:25 +0200
Subject: [PATCH 136/336] Improve performance of List#groupBy via a mutable
 buffer. Fix #288

---
 core/src/main/java/fj/data/List.java | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index ac846393..a4fa19eb 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -1398,14 +1398,15 @@ public final <B, C, D> TreeMap<B, D> groupBy(
       final D groupingIdentity,
       final F2<C, D, D> groupingAcc,
       final Ord<B> keyOrd) {
-    return this.foldLeft((map, element) -> {
-          final B key = keyFunction.f(element);
-          final C value = valueFunction.f(element);
-          return map.set(key, map.get(key)
-              .map(existing -> groupingAcc.f(value, existing))
-              .orSome(groupingAcc.f(value, groupingIdentity)));
-        }, TreeMap.empty(keyOrd)
-    );
+    java.util.TreeMap<B, D> buffer = new java.util.TreeMap<>(keyOrd.toComparator());
+    foreachDoEffect(element -> {
+      final B key = keyFunction.f(element);
+      final C value = valueFunction.f(element);
+      buffer.put(key, buffer.containsKey(key)
+          ? groupingAcc.f(value, buffer.get(key))
+          : groupingAcc.f(value, groupingIdentity));
+    });
+    return TreeMap.fromMutableMap(keyOrd, buffer);
   }
 
 

From 49c6f8d6fd51e92e32a0649205b3699aba1a60e6 Mon Sep 17 00:00:00 2001
From: JB Giraudeau <jb@giraudeau.info>
Date: Fri, 22 Jul 2016 14:32:05 +0200
Subject: [PATCH 137/336] Fix #293 regression. isGreaterThan(A)/isLesserThan(A)
 were not using strict inequality

---
 core/src/main/java/fj/Ord.java     |  4 ++--
 core/src/test/java/fj/OrdTest.java | 27 +++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)
 create mode 100644 core/src/test/java/fj/OrdTest.java

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 5c84c24e..df654a23 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -129,7 +129,7 @@ public boolean isGreaterThan(final A a1, final A a2) {
    * @return A function that returns true if its argument is less than the argument to this method.
    */
   public F<A, Boolean> isLessThan(final A a) {
-    return compose(o -> o != Ordering.LT, f.f(a));
+    return compose(o -> o == Ordering.GT, f.f(a));
   }
 
   /**
@@ -139,7 +139,7 @@ public F<A, Boolean> isLessThan(final A a) {
    * @return A function that returns true if its argument is greater than the argument to this method.
    */
   public F<A, Boolean> isGreaterThan(final A a) {
-    return compose(o -> o != Ordering.GT, f.f(a));
+    return compose(o -> o == Ordering.LT, f.f(a));
   }
 
   /**
diff --git a/core/src/test/java/fj/OrdTest.java b/core/src/test/java/fj/OrdTest.java
new file mode 100644
index 00000000..d218387a
--- /dev/null
+++ b/core/src/test/java/fj/OrdTest.java
@@ -0,0 +1,27 @@
+package fj;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class OrdTest {
+
+  @Test
+  public void isGreaterThan() {
+    F<Long, Boolean> pred = Ord.longOrd.isGreaterThan(1L);
+
+    assertThat(pred.f(0L), is(false));
+    assertThat(pred.f(1L), is(false));
+    assertThat(pred.f(2L), is(true));
+  }
+
+  @Test
+  public void isLessThan() {
+    F<Long, Boolean> pred = Ord.longOrd.isLessThan(1L);
+
+    assertThat(pred.f(0L), is(true));
+    assertThat(pred.f(1L), is(false));
+    assertThat(pred.f(2L), is(false));
+  }
+}

From e6abe86c7527ffafae908710e14c2212ff865007 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Thu, 15 Sep 2016 14:13:03 -0400
Subject: [PATCH 138/336] Add tests for Strings (#295)

---
 .../test/java/fj/function/StringsTest.java    | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 core/src/test/java/fj/function/StringsTest.java

diff --git a/core/src/test/java/fj/function/StringsTest.java b/core/src/test/java/fj/function/StringsTest.java
new file mode 100644
index 00000000..92cf44d3
--- /dev/null
+++ b/core/src/test/java/fj/function/StringsTest.java
@@ -0,0 +1,67 @@
+package fj.function;
+
+import fj.Function;
+import org.junit.Test;
+
+import static fj.F1Functions.o;
+import static fj.Function.compose;
+import static fj.function.Strings.*;
+import static org.junit.Assert.*;
+import static org.hamcrest.core.Is.is;
+
+public class StringsTest {
+    @Test
+    public void testLines() {
+        assertThat(compose(unlines(), lines()).f("one two three"), is("one two three"));
+    }
+
+    @Test
+    public void testLinesEmpty() {
+        assertThat(o(unlines(), lines()).f(""), is(""));
+    }
+
+    @Test
+    public void testLength() {
+        assertThat(length.f("functionaljava"), is(14));
+    }
+
+    @Test
+    public void testMatches() {
+        assertThat(matches.f("foo").f("foo"), is(true));
+    }
+
+    @Test
+    public void testContains() {
+        assertThat(contains.f("bar").f("foobar1"), is(true));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testIsEmptyException() {
+        assertThat(isEmpty.f(null), is(true));
+    }
+
+    @Test
+    public void testIsEmpty() {
+        assertThat(isEmpty.f(""), is(true));
+    }
+
+    @Test
+    public void testIsNotNullOrEmpty() {
+        assertThat(isNotNullOrEmpty.f("foo"), is(true));
+    }
+
+    @Test
+    public void testIsNullOrEmpty() {
+        assertThat(isNullOrEmpty.f(null), is(true));
+    }
+
+    @Test
+    public void testIsNotNullOrBlank() {
+        assertThat(isNotNullOrBlank.f("foo"), is(true));
+    }
+
+    @Test
+    public void testIsNullOrBlank() {
+        assertThat(isNullOrBlank.f("  "), is(true));
+    }
+}

From 2798b2c4101585a887a1ba9dc4608ac1d752f237 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 00:32:38 +0200
Subject: [PATCH 139/336] Avoid unecessary currying in uncurried version of
 foldRight.

---
 core/src/main/java/fj/data/List.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index a4fa19eb..da4a624e 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -716,7 +716,7 @@ public final List<A> append(final List<A> as) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight(final F<A, F<B, B>> f, final B b) {
-    return reverse().foldLeft(flip(f), b);
+    return foldRight(uncurryF2(f), b);
   }
 
   /**
@@ -727,7 +727,7 @@ public final <B> B foldRight(final F<A, F<B, B>> f, final B b) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight(final F2<A, B, B> f, final B b) {
-    return foldRight(curry(f), b);
+    return reverse().foldLeft(flip(f), b);
   }
 
   /**

From bd665e14ac9f07333c1fcd81c56884de1c26dc9f Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 00:34:09 +0200
Subject: [PATCH 140/336] NonEmtyList. Add uncurried version of
 foldRight/foldLeft + append(List).

---
 core/src/main/java/fj/data/NonEmptyList.java | 27 +++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index db994dc0..da06e0f4 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -8,6 +8,7 @@
 
 import static fj.Function.flip;
 import static fj.Function.identity;
+import static fj.Function.uncurryF2;
 import static fj.data.Option.some;
 import static fj.data.Option.somes;
 
@@ -73,6 +74,16 @@ public NonEmptyList<A> snoc(final A a) {
    */
   public int length() { return 1 + tail.length(); }
 
+  /**
+   * Appends the given list to this list.
+   *
+   * @param as The list to append.
+   * @return A new list with the given list appended.
+   */
+  public NonEmptyList<A> append(final List<A> as) {
+    return nel(head, tail.append(as));
+  }
+
   /**
    * Appends the given list to this list.
    *
@@ -95,14 +106,28 @@ public final A foldRight1(final F<A, F<A, A>> f) {
     return reverse().foldLeft1(flip(f));
   }
 
+  /**
+   * Performs a right-fold reduction across this list. This function uses O(length) stack space.
+   */
+  public final A foldRight1(final F2<A, A, A> f) {
+    return reverse().foldLeft1(flip(f));
+  }
+
   /**
    * Performs a left-fold reduction across this list. This function runs in constant space.
    */
   public final A foldLeft1(final F<A, F<A, A>> f) {
+    return foldLeft1(uncurryF2(f));
+  }
+
+  /**
+   * Performs a left-fold reduction across this list. This function runs in constant space.
+   */
+  public final A foldLeft1(final F2<A, A, A> f) {
     A x = head;
 
     for (List<A> xs = tail; !xs.isEmpty(); xs = xs.tail()) {
-      x = f.f(x).f(xs.head());
+      x = f.f(x, xs.head());
     }
 
     return x;

From 87d9b30e8ecdb8775637426022e36c25601ca8e2 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 00:35:20 +0200
Subject: [PATCH 141/336] Stream: Avoid unecessary currying in uncurried
 version of foldRight.

---
 core/src/main/java/fj/data/Stream.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index ae37d714..b3fa156d 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -119,7 +119,7 @@ public final <B> B uncons(final B nil, final F<A, F<P1<Stream<A>>, B>> cons) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight(final F<A, F<P1<B>, B>> f, final B b) {
-    return isEmpty() ? b : f.f(head()).f(P.lazy(() -> tail()._1().foldRight(f, b)));
+    return foldRight(uncurryF2(f), b);
   }
 
   /**
@@ -130,7 +130,7 @@ public final <B> B foldRight(final F<A, F<P1<B>, B>> f, final B b) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight(final F2<A, P1<B>, B> f, final B b) {
-    return foldRight(curry(f), b);
+    return isEmpty() ? b : f.f(head(), P.lazy(() -> tail()._1().foldRight(f, b)));
   }
 
   /**
@@ -141,7 +141,7 @@ public final <B> B foldRight(final F2<A, P1<B>, B> f, final B b) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight1(final F<A, F<B, B>> f, final B b) {
-    return foldRight(compose(Function.<P1<B>, B, B>andThen().f(P1.__1()), f), b);
+    return foldRight1(uncurryF2(f), b);
   }
 
   /**
@@ -152,7 +152,7 @@ public final <B> B foldRight1(final F<A, F<B, B>> f, final B b) {
    * @return The final result after the right-fold reduction.
    */
   public final <B> B foldRight1(final F2<A, B, B> f, final B b) {
-    return foldRight1(curry(f), b);
+    return isEmpty() ? b : f.f(head(), tail()._1().foldRight1(f, b));
   }
 
   /**

From 7aa9e3b79989b3ce9d2388094913ea3f393b0686 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 00:45:32 +0200
Subject: [PATCH 142/336] Monoid/Semigroup: implement optimizable/optimized
 definitions. + add generic compose and xmap + deprecate double semigroups due
 to round errors.

---
 core/src/main/java/fj/Monoid.java             | 781 ++++++++++++++++--
 core/src/main/java/fj/Ord.java                |  75 +-
 core/src/main/java/fj/Semigroup.java          | 392 +++++++--
 core/src/main/java/fj/data/optic/Fold.java    |   2 +-
 .../main/java/fj/data/optic/PTraversal.java   |   2 +-
 core/src/main/java/fj/function/Doubles.java   |  17 +-
 .../java/fj/demo/concurrent/WordCount.java    |   7 +-
 7 files changed, 1097 insertions(+), 179 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 3436d5a3..a342b8c7 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -1,18 +1,22 @@
 package fj;
 
-import static fj.Function.curry;
-import static fj.Function.flip;
+import static fj.F1Functions.dimap;
+
 import fj.data.Array;
+import fj.data.DList;
 import fj.data.List;
 import fj.data.IO;
-import fj.data.IOFunctions;
 import fj.data.Natural;
 import fj.data.Option;
 import fj.data.Set;
 import fj.data.Stream;
 
-import static fj.Function.flip;
-import static fj.Semigroup.multiply1p;
+import static fj.Function.*;
+import static fj.Semigroup.semigroupDef;
+import static fj.Unit.unit;
+import static fj.data.List.nil;
+import static fj.data.Natural.natural;
+import static fj.data.Option.none;
 import static fj.data.Stream.iterableStream;
 
 import java.math.BigInteger;
@@ -30,20 +34,83 @@
  * @version %build.number%
  */
 public final class Monoid<A> {
-  private final F<A, F<A, A>> sum;
-  private final A zero;
 
-  private Monoid(final F<A, F<A, A>> sum, final A zero) {
-    this.sum = sum;
-    this.zero = zero;
+
+  private final Definition<A> def;
+
+  public interface Definition<A> extends Semigroup.Definition<A> {
+
+    A empty();
+
+
+    default A sum(F0<Stream<A>> as) {
+      return as.f().foldLeft(this::append, empty());
+    }
+
+    @Override
+    default A sum(A a, F0<Stream<A>> as) {
+      return sum(() -> Stream.cons(a, as));
+    }
+
+    default A multiply(int n, A a) {
+      return (n <= 0)
+          ? empty()
+          : Semigroup.Definition.super.multiply1p(n - 1, a);
+    }
+
+    @Override
+    default A multiply1p(int n, A a) {
+      return n == Integer.MAX_VALUE
+          ? append(a, multiply(n, a))
+          : multiply(n + 1, a);
+    }
+
+    default Definition<A> dual() {
+      return new Definition<A>(){
+
+        @Override
+        public A empty() {
+          return Definition.this.empty();
+        }
+
+        @Override
+        public A append(A a1, A a2) {
+          return Definition.this.append(a2, a1);
+        }
+
+        @Override
+        public A multiply(int n, A a) {
+          return Definition.this.multiply(n, a);
+        }
+
+        @Override
+        public Definition<A> dual() {
+          return Definition.this;
+        }
+      };
+    }
+  }
+
+  public interface AltDefinition<A> extends Definition<A> {
+
+    @Override
+    F<A, A> prepend(A a);
+
+    @Override
+    default A append(A a1, A a2) {
+      return prepend(a1).f(a2);
+    }
+  }
+
+  private Monoid(Definition<A> def) {
+    this.def = def;
   }
 
   /**
    * Composes this monoid with another.
    */
   public <B> Monoid<P2<A,B>>compose(Monoid<B> m) {
-    return monoid((P2<A,B> x) -> (P2<A,B> y) ->
-      P.p(sum(x._1(), y._1()), m.sum(x._2(), y._2())), P.p(zero, m.zero));
+    return compose(m, P2.__1(), P2.__2(), P::p);
   }
 
   /**
@@ -52,7 +119,81 @@ private Monoid(final F<A, F<A, A>> sum, final A zero) {
    * @return A semigroup projection of this monoid.
    */
   public Semigroup<A> semigroup() {
-    return Semigroup.semigroup(sum);
+    return semigroupDef(def);
+  }
+
+  /**
+   * Maps the given functions across this monoid as an invariant functor.
+   *
+   * @param f The covariant map.
+   * @param g The contra-variant map.
+   * @return A new monoid.
+   */
+  public <B> Monoid<B> xmap(final F<A, B> f, final F<B, A> g) {
+    Monoid.Definition<A> def = this.def;
+    B zero = f.f(def.empty());
+    return monoidDef(new Definition<B>() {
+      @Override
+      public B empty() {
+        return zero;
+      }
+
+      @Override
+      public B append(B a1, B a2) {
+        return f.f(def.append(g.f(a1), g.f(a2)));
+      }
+
+      @Override
+      public F<B, B> prepend(B b) {
+        return dimap(def.prepend(g.f(b)), g, f);
+      }
+
+      @Override
+      public B multiply(int n, B b) {
+        return f.f(def.multiply(n , g.f(b)));
+      }
+
+      @Override
+      public B sum(F0<Stream<B>> as) {
+        return f.f(def.sum(() -> as.f().map(g)));
+      }
+    });
+  }
+
+
+  public <B, C> Monoid<C> compose(Monoid<B> mb, final F<C, A> a, final F<C, B> b, final F2<A, B, C> c) {
+    Definition<A> maDef = this.def;
+    Definition<B> mbDef = mb.def;
+    C empty = c.f(maDef.empty(), mbDef.empty());
+    return monoidDef(new Definition<C>() {
+
+      @Override
+      public C empty() {
+        return empty;
+      }
+
+      @Override
+      public C append(C c1, C c2) {
+        return c.f(maDef.append(a.f(c1), a.f(c2)), mbDef.append(b.f(c1), b.f(c2)));
+      }
+
+      @Override
+      public F<C, C> prepend(C c1) {
+        F<A, A> prependA = maDef.prepend(a.f(c1));
+        F<B, B> prependB = mbDef.prepend(b.f(c1));
+        return c2 -> c.f(prependA.f(a.f(c2)), prependB.f(b.f(c2)));
+      }
+
+      @Override
+      public C multiply(int n, C c1) {
+        return c.f(maDef.multiply(n, a.f(c1)), mbDef.multiply(n, b.f(c1)));
+      }
+
+      @Override
+      public C sum(F0<Stream<C>> cs) {
+        return c.f(maDef.sum(() -> cs.f().map(a)), mbDef.sum(() -> cs.f().map(b)));
+      }
+    });
   }
 
   /**
@@ -63,7 +204,7 @@ public Semigroup<A> semigroup() {
    * @return The of the two given arguments.
    */
   public A sum(final A a1, final A a2) {
-    return sum.f(a1).f(a2);
+    return def.append(a1, a2);
   }
 
   /**
@@ -73,7 +214,7 @@ public A sum(final A a1, final A a2) {
    * @return A function that sums the given value according to this monoid.
    */
   public F<A, A> sum(final A a1) {
-    return sum.f(a1);
+    return def.prepend(a1);
   }
 
   /**
@@ -82,7 +223,7 @@ public F<A, A> sum(final A a1) {
    * @return A function that sums according to this monoid.
    */
   public F<A, F<A, A>> sum() {
-    return sum;
+    return def::prepend;
   }
 
   /**
@@ -91,7 +232,7 @@ public F<A, F<A, A>> sum() {
    * @return The zero value for this monoid.
    */
   public A zero() {
-    return zero;
+    return def.empty();
   }
 
   /**
@@ -106,9 +247,7 @@ public A zero() {
    * {@code zero()}
    */
   public A multiply(final int n, final A a) {
-    return (n <= 0)
-        ? zero
-        : multiply1p(sum, n - 1, a);
+    return def.multiply(n, a);
   }
 
   /**
@@ -118,7 +257,7 @@ public A multiply(final int n, final A a) {
    * @return The sum of the given values.
    */
   public A sumRight(final List<A> as) {
-    return as.foldRight(sum, zero);
+    return as.foldRight(def::append, def.empty());
   }
 
   /**
@@ -128,7 +267,7 @@ public A sumRight(final List<A> as) {
    * @return The sum of the given values.
    */
   public A sumRight(final Stream<A> as) {
-    return as.foldRight((a, ap1) -> sum(a, ap1._1()), zero);
+    return as.foldRight1(def::append, def.empty());
   }
 
   /**
@@ -138,7 +277,7 @@ public A sumRight(final Stream<A> as) {
    * @return The sum of the given values.
    */
   public A sumLeft(final List<A> as) {
-    return as.foldLeft(sum, zero);
+    return as.foldLeft(def::append, def.empty());
   }
 
   /**
@@ -148,7 +287,7 @@ public A sumLeft(final List<A> as) {
    * @return The sum of the given values.
    */
   public A sumLeft(final Stream<A> as) {
-    return as.foldLeft(sum, zero);
+    return def.sum(() -> as);
   }
 
   /**
@@ -187,147 +326,495 @@ public F<Stream<A>, A> sumLeftS() {
    */
   public A join(final Iterable<A> as, final A a) {
     final Stream<A> s = iterableStream(as);
-    return s.isEmpty() ?
-           zero :
-           s.foldLeft1(Function.compose(sum, flip(sum).f(a)));
+    F<A, A> prependA = def.prepend(a);
+    return s.isEmpty()
+           ? def.empty()
+           : s.foldLeft1((a1, a2) -> def.append(a1, prependA.f(a2)));
   }
 
   /**
    * Swaps the arguments when summing.
    */
   public Monoid<A> dual() {
-    return monoid(flip(sum), zero);
+    return monoidDef(def.dual());
+  }
+
+  /**
+   * Constructs a monoid from the given definition, which must follow the monoidal
+   * laws.
+   *
+   * @param def  The definition for the monoid.
+   * @return A monoid instance that uses the given sun function and zero value.
+   */
+  public static <A> Monoid<A> monoidDef(Definition<A> def) {
+    return new Monoid<>(def);
+  }
+
+  /**
+   * Constructs a monoid from the given definition, which must follow the monoidal
+   * laws.
+   *
+   * @param def  The definition for the monoid.
+   * @return A monoid instance that uses the given sun function and zero value.
+   */
+  public static <A> Monoid<A> monoidDef(AltDefinition<A> def) {
+    return new Monoid<>(def);
+  }
+
+  /**
+   * Constructs a monoid from the given semigroup definition and zero value, which must follow the monoidal laws.
+   *
+   * @param s    The semigroup definition for the monoid.
+   * @param zero The zero for the monoid.
+   * @return A monoid instance that uses the given sun function and zero value.
+   */
+  public static <A> Monoid<A> monoidDef(final Semigroup.Definition<A> s, final A zero) {
+    return new Monoid<>(new Monoid.Definition<A>() {
+      @Override
+      public A empty() {
+        return zero;
+      }
+
+      @Override
+      public A sum(F0<Stream<A>> as) {
+        return s.sum(zero, as);
+      }
+
+      @Override
+      public A sum(A a, F0<Stream<A>> as) {
+        return s.sum(a, as);
+      }
+
+      @Override
+      public A multiply(int n, A a) {
+        return (n <= 0)
+            ? zero
+            : s.multiply1p(n - 1, a);
+      }
+
+      @Override
+      public A multiply1p(int n, A a) {
+        return s.multiply1p(n, a);
+      }
+
+      @Override
+      public A append(A a1, A a2) {
+        return s.append(a1, a2);
+      }
+
+      @Override
+      public F<A, A> prepend(A a) {
+        return s.prepend(a);
+      }
+    });
+  }
+
+  /**
+   * Constructs a monoid from the given semigroup definition and zero value, which must follow the monoidal laws.
+   *
+   * @param s    The semigroup definition for the monoid.
+   * @param zero The zero for the monoid.
+   * @return A monoid instance that uses the given sun function and zero value.
+   */
+  public static <A> Monoid<A> monoidDef(final Semigroup.AltDefinition<A> s, final A zero) {
+    return monoidDef((Semigroup.Definition<A>) s, zero);
   }
 
   /**
    * Constructs a monoid from the given sum function and zero value, which must follow the monoidal
    * laws.
+   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} instead.
    *
    * @param sum  The sum function for the monoid.
    * @param zero The zero for the monoid.
    * @return A monoid instance that uses the given sun function and zero value.
    */
+  @Deprecated
   public static <A> Monoid<A> monoid(final F<A, F<A, A>> sum, final A zero) {
-    return new Monoid<>(sum, zero);
+    return new Monoid<>(new AltDefinition<A>() {
+      @Override
+      public F<A, A> prepend(A a) {
+        return sum.f(a);
+      }
+
+      @Override
+      public A empty() {
+        return zero;
+      }
+    });
   }
 
   /**
    * Constructs a monoid from the given sum function and zero value, which must follow the monoidal
    * laws.
+   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} instead.
    *
    * @param sum  The sum function for the monoid.
    * @param zero The zero for the monoid.
    * @return A monoid instance that uses the given sun function and zero value.
    */
+  @Deprecated
   public static <A> Monoid<A> monoid(final F2<A, A, A> sum, final A zero) {
-    return new Monoid<>(curry(sum), zero);
+    return new Monoid<>(new Definition<A>() {
+      @Override
+      public A empty() {
+        return zero;
+      }
+
+      @Override
+      public A append(A a1, A a2) {
+        return sum.f(a1, a2);
+      }
+    });
   }
 
   /**
    * Constructs a monoid from the given semigroup and zero value, which must follow the monoidal laws.
+   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} or {@link Semigroup#monoid(Object)} instead.
    *
    * @param s    The semigroup for the monoid.
    * @param zero The zero for the monoid.
    * @return A monoid instance that uses the given sun function and zero value.
    */
+  @Deprecated
   public static <A> Monoid<A> monoid(final Semigroup<A> s, final A zero) {
-    return new Monoid<>(s.sum(), zero);
+    return s.monoid(zero);
   }
 
+
   /**
    * A monoid that adds integers.
    */
-  public static final Monoid<Integer> intAdditionMonoid = monoid(Semigroup.intAdditionSemigroup, 0);
+  public static final Monoid<Integer> intAdditionMonoid = monoidDef(new Definition<Integer>() {
+    @Override
+    public Integer empty() {
+      return 0;
+    }
+
+    @Override
+    public Integer append(Integer a1, Integer a2) {
+      return a1 + a2;
+    }
+
+    @Override
+    public Integer multiply(int n, Integer i) {
+      return n <= 0 ? 0 : n * i;
+    }
+  });
 
   /**
    * A monoid that multiplies integers.
    */
-  public static final Monoid<Integer> intMultiplicationMonoid = monoid(Semigroup.intMultiplicationSemigroup, 1);
+  public static final Monoid<Integer> intMultiplicationMonoid = monoidDef(new Definition<Integer>() {
+    @Override
+    public Integer empty() {
+      return 1;
+    }
+
+    @Override
+    public Integer append(Integer i1, Integer i2) {
+      return i1 * i2;
+    }
+
+    @Override
+    public Integer sum(F0<Stream<Integer>> as) {
+      int x = 1;
+      for (Stream<Integer> xs = as.f(); x != 0 && !xs.isEmpty(); xs = xs.tail()._1()) {
+        x *= xs.head();
+      }
+      return x;
+    }
+
+    @Override
+    public Integer multiply(int n, Integer integer) {
+      return n <= 0 ? 1 : (int) StrictMath.pow(integer.doubleValue(), n);
+    }
+  });
 
   /**
-   * A monoid that adds doubles.
+   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
    */
-  public static final Monoid<Double> doubleAdditionMonoid = monoid(Semigroup.doubleAdditionSemigroup, 0.0);
+  @Deprecated
+  public static final Monoid<Double> doubleAdditionMonoid = monoidDef((d1, d2) -> d1 + d2, 0.0);
 
   /**
-   * A monoid that multiplies doubles.
+   * @deprecated Since 4.7. Due to rounding errors, multiplication of doubles does not comply with monoid laws
    */
-  public static final Monoid<Double> doubleMultiplicationMonoid = monoid(Semigroup.doubleMultiplicationSemigroup, 1.0);
+  @Deprecated
+  public static final Monoid<Double> doubleMultiplicationMonoid = monoidDef((d1, d2) -> d1 * d2, 1.0);
 
   /**
    * A monoid that adds big integers.
    */
-  public static final Monoid<BigInteger> bigintAdditionMonoid = monoid(Semigroup.bigintAdditionSemigroup, BigInteger.ZERO);
+  public static final Monoid<BigInteger> bigintAdditionMonoid = monoidDef(new Definition<BigInteger>() {
+    @Override
+    public BigInteger empty() {
+      return BigInteger.ZERO;
+    }
+
+    @Override
+    public BigInteger append(BigInteger a1, BigInteger a2) {
+      return a1.add(a2);
+    }
+
+    @Override
+    public BigInteger multiply(int n, BigInteger a) {
+      return n <= 0 ? BigInteger.ZERO : a.multiply(BigInteger.valueOf(n));
+    }
+  });
 
   /**
    * A monoid that multiplies big integers.
    */
-  public static final Monoid<BigInteger> bigintMultiplicationMonoid =
-      monoid(Semigroup.bigintMultiplicationSemigroup, BigInteger.ONE);
+  public static final Monoid<BigInteger> bigintMultiplicationMonoid = monoidDef(new Definition<BigInteger>() {
+    @Override
+    public BigInteger empty() {
+      return BigInteger.ONE;
+    }
+
+    @Override
+    public BigInteger append(BigInteger a1, BigInteger a2) {
+      return a1.multiply(a2);
+    }
+
+    @Override
+    public BigInteger multiply(int n, BigInteger a) {
+      return n <= 0 ? BigInteger.ONE : a.pow(n);
+    }
+
+  });
 
   /**
    * A monoid that adds big decimals.
    */
   public static final Monoid<BigDecimal> bigdecimalAdditionMonoid =
-      monoid(Semigroup.bigdecimalAdditionSemigroup, BigDecimal.ZERO);
+      monoidDef(new Definition<BigDecimal>() {
+        @Override
+        public BigDecimal empty() {
+          return BigDecimal.ZERO;
+        }
+
+        @Override
+        public BigDecimal append(BigDecimal a1, BigDecimal a2) {
+          return a1.add(a2);
+        }
+
+        @Override
+        public BigDecimal multiply(int n, BigDecimal a) {
+          return n <= 0 ? BigDecimal.ZERO : a.multiply(BigDecimal.valueOf(n));
+        }
+      });
 
   /**
    * A monoid that multiplies big decimals.
    */
   public static final Monoid<BigDecimal> bigdecimalMultiplicationMonoid =
-      monoid(Semigroup.bigdecimalMultiplicationSemigroup, BigDecimal.ONE);
+      monoidDef(new Definition<BigDecimal>() {
+        @Override
+        public BigDecimal empty() {
+          return BigDecimal.ONE;
+        }
+
+        @Override
+        public BigDecimal append(BigDecimal a1, BigDecimal a2) {
+          return a1.multiply(a2);
+        }
+
+        @Override
+        public BigDecimal multiply(int n, BigDecimal decimal) {
+          return n <= 0 ? BigDecimal.ONE : decimal.pow(n);
+        }
+      });
+
+
 
   /**
    * A monoid that adds natural numbers.
    */
   public static final Monoid<Natural> naturalAdditionMonoid =
-      monoid(Semigroup.naturalAdditionSemigroup, Natural.ZERO);
+      monoidDef(new Definition<Natural>() {
+        @Override
+        public Natural empty() {
+          return Natural.ZERO;
+        }
+
+        @Override
+        public Natural append(Natural a1, Natural a2) {
+          return a1.add(a2);
+        }
+
+        @Override
+        public Natural multiply(int n, Natural a) {
+          return natural(n).map(positiveN -> a.multiply(positiveN)).orSome(Natural.ZERO);
+        }
+      });
 
   /**
    * A monoid that multiplies natural numbers.
    */
   public static final Monoid<Natural> naturalMultiplicationMonoid =
-      monoid(Semigroup.naturalMultiplicationSemigroup, Natural.ONE);
+      monoidDef(new Definition<Natural>() {
+        @Override
+        public Natural empty() {
+          return Natural.ONE;
+        }
+
+        @Override
+        public Natural append(Natural a1, Natural a2) {
+          return a1.multiply(a2);
+        }
+      });
 
   /**
    * A monoid that adds longs.
    */
-  public static final Monoid<Long> longAdditionMonoid = monoid(Semigroup.longAdditionSemigroup, 0L);
+  public static final Monoid<Long> longAdditionMonoid = monoidDef(new Definition<Long>() {
+    @Override
+    public Long empty() {
+      return 0L;
+    }
+
+    @Override
+    public Long append(Long a1, Long a2) {
+      return a1 + a2;
+    }
+
+    @Override
+    public Long multiply(int n, Long a) {
+      return n <= 0 ? 0L : n * a;
+    }
+  });
 
   /**
    * A monoid that multiplies longs.
    */
-  public static final Monoid<Long> longMultiplicationMonoid = monoid(Semigroup.longMultiplicationSemigroup, 1L);
+  public static final Monoid<Long> longMultiplicationMonoid = monoidDef(new Definition<Long>() {
+    @Override
+    public Long empty() {
+      return 1L;
+    }
+
+    @Override
+    public Long append(Long i1, Long i2) {
+      return i1 * i2;
+    }
+
+    @Override
+    public Long sum(F0<Stream<Long>> as) {
+      long x = 1L;
+      for (Stream<Long> xs = as.f(); x != 0L && !xs.isEmpty(); xs = xs.tail()._1()) {
+        x *= xs.head();
+      }
+      return x;
+    }
+
+    @Override
+    public Long multiply(int n, Long l) {
+      return n <= 0 ? 1L : (long) StrictMath.pow(l.doubleValue(), n);
+    }
+  });
 
   /**
    * A monoid that ORs booleans.
    */
-  public static final Monoid<Boolean> disjunctionMonoid = monoid(Semigroup.disjunctionSemigroup, false);
+  public static final Monoid<Boolean> disjunctionMonoid = monoidDef(new Definition<Boolean>() {
+    @Override
+    public Boolean empty() {
+      return false;
+    }
+
+    @Override
+    public Boolean append(Boolean a1, Boolean a2) {
+      return a1 | a2;
+    }
+
+    @Override
+    public Boolean sum(F0<Stream<Boolean>> as) {
+      return as.f().filter(identity()).isNotEmpty();
+    }
+
+    @Override
+    public Boolean multiply(int n, Boolean a) {
+      return n <= 0 ? false : a;
+    }
+  });
 
   /**
    * A monoid that XORs booleans.
    */
-  public static final Monoid<Boolean> exclusiveDisjunctionMonoid = monoid(Semigroup.exclusiveDisjunctionSemiGroup, false);
+  public static final Monoid<Boolean> exclusiveDisjunctionMonoid = monoidDef(new Definition<Boolean>() {
+    @Override
+    public Boolean empty() {
+      return false;
+    }
+
+    @Override
+    public Boolean append(Boolean a1, Boolean a2) {
+      return a1 ^ a2;
+    }
+
+    @Override
+    public Boolean multiply(int n, Boolean a) {
+      return a && (n == 1);
+    }
+  });
 
   /**
    * A monoid that ANDs booleans.
    */
-  public static final Monoid<Boolean> conjunctionMonoid = monoid(Semigroup.conjunctionSemigroup, true);
+  public static final Monoid<Boolean> conjunctionMonoid = monoidDef(new Definition<Boolean>() {
+    @Override
+    public Boolean empty() {
+      return true;
+    }
+
+    @Override
+    public Boolean append(Boolean a1, Boolean a2) {
+      return a1 & a2;
+    }
+
+    @Override
+    public Boolean multiply(int n, Boolean a) {
+      return a;
+    }
+
+    @Override
+    public Boolean sum(F0<Stream<Boolean>> as) {
+      return as.f().filter(a -> !a).isEmpty();
+    }
+  });
 
   /**
    * A monoid that appends strings.
    */
-  public static final Monoid<String> stringMonoid = monoid(Semigroup.stringSemigroup, "");
+  public static final Monoid<String> stringMonoid = monoidDef(new Definition<String>() {
+    @Override
+    public String empty() {
+      return "";
+    }
+
+    @Override
+    public String append(String a1, String a2) {
+      return a1.concat(a2);
+    }
+
+    @Override
+    public String sum(F0<Stream<String>> as) {
+      StringBuilder sb = new StringBuilder();
+      as.f().foreachDoEffect(sb::append);
+      return sb.toString();
+    }
+  });
 
   /**
    * A monoid that appends string buffers.
    */
-  public static final Monoid<StringBuffer> stringBufferMonoid = monoid(Semigroup.stringBufferSemigroup, new StringBuffer());
+  public static final Monoid<StringBuffer> stringBufferMonoid = monoidDef((s1, s2) -> new StringBuffer(s1).append(s2),  new StringBuffer(0));
 
   /**
    * A monoid that appends string builders.
    */
-  public static final Monoid<StringBuilder> stringBuilderMonoid = monoid(Semigroup.stringBuilderSemigroup, new StringBuilder());
+  public static final Monoid<StringBuilder> stringBuilderMonoid = monoidDef((s1, s2) -> new StringBuilder(s1).append(s2),  new StringBuilder(0));
 
   /**
    * A monoid for functions.
@@ -336,7 +823,18 @@ public static <A> Monoid<A> monoid(final Semigroup<A> s, final A zero) {
    * @return A monoid for functions.
    */
   public static <A, B> Monoid<F<A, B>> functionMonoid(final Monoid<B> mb) {
-    return monoid(Semigroup.functionSemigroup(mb.semigroup()), Function.constant(mb.zero));
+    Definition<B> mbDef = mb.def;
+    return monoidDef(new Definition<F<A, B>>() {
+      @Override
+      public F<A, B> empty() {
+        return __ -> mbDef.empty();
+      }
+
+      @Override
+      public F<A, B> append(F<A, B> a1, F<A, B> a2) {
+        return a -> mbDef.append(a1.f(a), a2.f(a));
+      }
+    });
   }
 
   /**
@@ -345,16 +843,33 @@ public static <A, B> Monoid<F<A, B>> functionMonoid(final Monoid<B> mb) {
    * @return A monoid for lists.
    */
   public static <A> Monoid<List<A>> listMonoid() {
-    return monoid(Semigroup.listSemigroup(), List.nil());
+    return monoidDef(new Definition<List<A>>() {
+      @Override
+      public List<A> empty() {
+        return nil();
+      }
+
+      @Override
+      public List<A> append(List<A> a1, List<A> a2) {
+        return a1.append(a2);
+      }
+
+      @Override
+      public List<A> sum(F0<Stream<List<A>>> as) {
+        return as.f().map(DList::listDList).foldLeft(DList::append, DList.<A>nil()).run();
+      }
+    });
   }
 
   /**
    * A monoid for options.
+   * @deprecated since 4.7. Use {@link #firstOptionMonoid()}.
    *
    * @return A monoid for options.
    */
+  @Deprecated
   public static <A> Monoid<Option<A>> optionMonoid() {
-    return monoid(Semigroup.optionSemigroup(), Option.none());
+    return firstOptionMonoid();
   }
 
   /**
@@ -363,7 +878,32 @@ public static <A> Monoid<Option<A>> optionMonoid() {
    * @return A monoid for options that take the first available value.
    */
   public static <A> Monoid<Option<A>> firstOptionMonoid() {
-    return monoid(Semigroup.firstOptionSemigroup(), Option.none());
+    return monoidDef(new Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a1.orElse(a2);
+      }
+
+      @Override
+      public F<Option<A>, Option<A>> prepend(Option<A> a1) {
+        return a1.isSome() ? __ -> a1 : identity();
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> as) {
+        return as;
+      }
+
+      @Override
+      public Option<A> sum(F0<Stream<Option<A>>> as) {
+        return as.f().filter(Option.isSome_()).orHead(Option::none);
+      }
+    });
   }
 
   /**
@@ -372,7 +912,27 @@ public static <A> Monoid<Option<A>> firstOptionMonoid() {
    * @return A monoid for options that take the last available value.
    */
   public static <A> Monoid<Option<A>> lastOptionMonoid() {
-    return monoid(Semigroup.lastOptionSemigroup(), Option.none());
+    return monoidDef(new Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a2.orElse(a1);
+      }
+
+      @Override
+      public F<Option<A>, Option<A>> prepend(Option<A> a1) {
+        return a1.isNone() ? identity() : a2 -> a2.orElse(a1);
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> as) {
+        return as;
+      }
+    });
   }
 
   /**
@@ -381,7 +941,22 @@ public static <A> Monoid<Option<A>> lastOptionMonoid() {
    * @return A monoid for streams.
    */
   public static <A> Monoid<Stream<A>> streamMonoid() {
-    return monoid(Semigroup.streamSemigroup(), Stream.nil());
+    return monoidDef(new Definition<Stream<A>>() {
+      @Override
+      public Stream<A> empty() {
+        return Stream.nil();
+      }
+
+      @Override
+      public Stream<A> append(Stream<A> a1, Stream<A> a2) {
+        return a1.append(a2);
+      }
+
+      @Override
+      public Stream<A> sum(F0<Stream<Stream<A>>> as) {
+        return Stream.join(as.f());
+      }
+    });
   }
 
   /**
@@ -391,30 +966,91 @@ public static <A> Monoid<Stream<A>> streamMonoid() {
    */
   @SuppressWarnings("unchecked")
   public static <A> Monoid<Array<A>> arrayMonoid() {
-    return monoid(Semigroup.arraySemigroup(), Array.empty());
+    return monoidDef(new Definition<Array<A>>() {
+      @Override
+      public Array<A> empty() {
+        return Array.empty();
+      }
+
+      @Override
+      public Array<A> append(Array<A> a1, Array<A> a2) {
+        return a1.append(a2);
+      }
+    });
   }
 
   /**
    * A monoid for IO values.
    */
-  public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
-    return monoid(Semigroup.ioSemigroup(ma.semigroup()), IOFunctions.unit(ma.zero()));
+  public static <A> Monoid<IO<A>> ioMonoid(final Monoid<A> ma) {
+    Definition<A> maDef = ma.def;
+    return monoidDef(new Definition<IO<A>>() {
+      @Override
+      public IO<A> empty() {
+        return () -> maDef.empty();
+      }
+
+      @Override
+      public IO<A> append(IO<A> a1, IO<A> a2) {
+        return () -> maDef.append(a1.run(), a2.run());
+      }
+    });
   }
 
   /**
    * A monoid for the maximum of two integers.
    */
-  public static final Monoid<Integer> intMaxMonoid = monoid(Semigroup.intMaximumSemigroup, Integer.MIN_VALUE);
+  public static final Monoid<Integer> intMaxMonoid = monoidDef(new Definition<Integer>() {
+    @Override
+    public Integer empty() {
+      return Integer.MIN_VALUE;
+    }
+
+    @Override
+    public Integer append(Integer a1, Integer a2) {
+      return Math.max(a1, a2);
+    }
+
+    @Override
+    public Integer multiply(int n, Integer a) {
+      return a;
+    }
+  });
 
   /**
    * A monoid for the minimum of two integers.
    */
-  public static final Monoid<Integer> intMinMonoid = monoid(Semigroup.intMinimumSemigroup, Integer.MAX_VALUE);
+  public static final Monoid<Integer> intMinMonoid = monoidDef(new Definition<Integer>() {
+    @Override
+    public Integer empty() {
+      return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public Integer append(Integer a1, Integer a2) {
+      return Math.min(a1, a2);
+    }
+
+    @Override
+    public Integer multiply(int n, Integer a) {
+      return a;
+    }
+  });
 
   /**
    * A monoid for the Unit value.
    */
-  public static final Monoid<Unit> unitMonoid = monoid(Semigroup.unitSemigroup, Unit.unit());
+  public static final Monoid<Unit> unitMonoid = monoidDef(new Definition<Unit>() {
+    @Override
+    public Unit empty() {
+      return unit();
+    }
+
+    @Override
+    public Unit append(Unit a1, Unit a2) {
+      return unit();
+    }
+  });
 
   /**
    * A monoid for sets.
@@ -423,18 +1059,29 @@ public static <A> Monoid<IO<A>> ioMonoid(final Monoid <A> ma) {
    * @return A monoid for sets whose elements have the given order.
    */
   public static <A> Monoid<Set<A>> setMonoid(final Ord<A> o) {
-    return monoid(Semigroup.setSemigroup(), Set.empty(o));
-  }
+    return monoidDef(new Definition<Set<A>>() {
+      @Override
+      public Set<A> empty() {
+        return Set.empty(o);
+      }
 
+      @Override
+      public Set<A> append(Set<A> a1, Set<A> a2) {
+        return a1.union(a2);
+      }
+    });
+  }
 
   /**
    * A monoid for the maximum of elements with ordering o.
+   * @deprecated since 4.7. Use {@link Ord#maxMonoid(Object)}
    *
    * @param o An ordering of elements.
    * @param zero The minimum element.
    */
+  @Deprecated
   public static <A> Monoid<A> ordMaxMonoid(final Ord<A> o, final A zero) {
-    return monoid(o.max, zero);
+    return o.maxMonoid(zero);
   }
 
 }
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 86d560b7..1764ea74 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -19,6 +19,7 @@
 import static fj.Function.compose2;
 import static fj.Function.curry;
 import static fj.Semigroup.semigroup;
+import static fj.Semigroup.semigroupDef;
 
 /**
  * Tests for ordering between two objects.
@@ -30,7 +31,7 @@ public final class Ord<A> {
   /**
    * Primitives functions of Ord: minimal definition and overridable methods.
    */
-  public interface Definition<A> extends Equal.Definition<A> {
+  public interface Definition<A> extends Equal.Definition<A>, Semigroup.Definition<A> {
 
     F<A, Ordering> compare(A a);
 
@@ -38,6 +39,7 @@ default Ordering compare(A a1, A a2) {
       return compare(a1).f(a2);
     }
 
+    // equal:
     @Override
     default boolean equal(A a1, A a2) {
       return compare(a1, a2) == Ordering.EQ;
@@ -47,6 +49,42 @@ default boolean equal(A a1, A a2) {
     default F<A, Boolean> equal(A a) {
       return compose(o -> o == Ordering.EQ, compare(a));
     }
+
+    // max semigroup:
+    @Override
+    default A append(A a1, A a2) {
+      return compare(a1, a2) == Ordering.GT ? a1 : a2;
+    }
+
+    @Override
+    default A multiply1p(int n, A a) {
+      return a;
+    }
+
+    @Override
+    default F<A, A> prepend(A a1) {
+      return apply((a2, o) -> o == Ordering.GT ? a1 : a2, compare(a1));
+    }
+
+    @Override
+    default Definition<A> dual() {
+      return new Definition<A>() {
+        @Override
+        public F<A, Ordering> compare(A a) {
+          return compose(Ordering::reverse, Definition.this.compare(a));
+        }
+
+        @Override
+        public Ordering compare(A a1, A a2) {
+          return Definition.this.compare(a2, a1);
+        }
+
+        @Override
+        public Definition<A> dual() {
+          return Definition.this;
+        }
+      };
+    }
   }
 
   /**
@@ -60,6 +98,11 @@ default F<A, Ordering> compare(A a1) {
       return a2 -> compare(a1, a2);
     }
 
+    @Override
+    default F<A, A> prepend(A a1) {
+      return a2 -> append(a1, a2);
+    }
+
   }
 
 
@@ -199,7 +242,7 @@ public F<A, Boolean> isGreaterThan(final A a) {
    * @return The greater of the two values.
    */
   public A max(final A a1, final A a2) {
-    return isGreaterThan(a1, a2) ? a1 : a2;
+    return def.append(a1, a2);
   }
 
 
@@ -216,6 +259,7 @@ public A min(final A a1, final A a2) {
 
   /**
    * A function that returns the greater of its two arguments.
+   *
    */
   public final F<A, F<A, A>> max;
 
@@ -225,34 +269,33 @@ public A min(final A a1, final A a2) {
   public final F<A, F<A, A>> min;
 
   public final Semigroup<A> minSemigroup() {
-      return semigroup(min);
+      return semigroupDef(def.dual());
+  }
+
+  public final Monoid<A> minMonoid(A zero) {
+    return Monoid.monoidDef(def.dual(), zero);
   }
 
   public final Semigroup<A> maxSemigroup() {
-      return semigroup(max);
+      return semigroupDef(def);
   }
 
-  public final Ord<A> reverse() {
-    Definition<A> selfDef = def;
-    return ordDef(new Definition<A>() {
-      @Override
-      public F<A, Ordering> compare(A a) {
-        return compose(Ordering::reverse, selfDef.compare(a));
-      }
+  public final Monoid<A> maxMonoid(A zero) {
+    return Monoid.monoidDef(def, zero);
+  }
 
-      @Override
-      public Ordering compare(A a1, A a2) {
-        return selfDef.compare(a2, a1);
-      }
-    });
+  public final Ord<A> reverse() {
+    return ordDef(def.dual());
   }
 
   /**
    * Returns an order instance that uses the given equality test and ordering function.
    *
+   * @deprecated since 4.7. Use {@link #ordDef(Definition)}.
    * @param f The order function.
    * @return An order instance.
    */
+  @Deprecated
   public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
     return new Ord<>(f::f);
   }
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 7c5538f2..cba1f04b 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -1,9 +1,9 @@
 package fj;
 
 import fj.data.Array;
+import fj.data.DList;
 import fj.data.List;
 import fj.data.IO;
-import fj.data.IOFunctions;
 import fj.data.Natural;
 import fj.data.NonEmptyList;
 import fj.data.Option;
@@ -13,8 +13,13 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
-import static fj.Function.curry;
-import static fj.Function.flip;
+import static fj.F1Functions.dimap;
+import static fj.Function.constant;
+import static fj.Function.identity;
+import static fj.Monoid.*;
+import static fj.data.DList.listDList;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
 
 /**
  * Implementations must satisfy the law of associativity:
@@ -25,10 +30,69 @@
  * @version %build.number%
  */
 public final class Semigroup<A> {
-  private final F<A, F<A, A>> sum;
 
-  private Semigroup(final F<A, F<A, A>> sum) {
-    this.sum = sum;
+  public interface Definition<A> {
+
+    A append(A a1, A a2);
+
+    default F<A, A> prepend(A a) {
+      return a2 -> append(a, a2);
+    }
+
+    default A sum(A a, F0<Stream<A>> as) {
+      return as.f().foldLeft(this::append, a);
+    }
+
+    default A multiply1p(int n, A a) {
+      if (n <= 0) {
+        return a;
+      }
+
+      A xTmp = a;
+      int yTmp = n;
+      A zTmp = a;
+      while (true) {
+        if ((yTmp & 1) == 1) {
+          zTmp = append(xTmp, zTmp);
+          if (yTmp == 1) {
+            return zTmp;
+          }
+        }
+        xTmp = append(xTmp, xTmp);
+        yTmp = (yTmp) >>> 1;
+      }
+    }
+
+    default Definition<A> dual() {
+      return new Definition<A>(){
+
+        @Override
+        public A append(A a1, A a2) {
+          return Definition.this.append(a2, a1);
+        }
+
+        @Override
+        public A multiply1p(int n, A a) {
+          return Definition.this.multiply1p(n, a);
+        }
+      };
+    }
+  }
+
+  public interface AltDefinition<A> extends Definition<A> {
+    @Override
+    F<A, A> prepend(A a);
+
+    @Override
+    default A append(A a1, A a2) {
+      return prepend(a1).f(a2);
+    }
+  }
+
+  private final Definition<A> def;
+
+  private Semigroup(final Definition<A> def) {
+    this.def = def;
   }
 
   /**
@@ -39,7 +103,7 @@ private Semigroup(final F<A, F<A, A>> sum) {
    * @return The of the two given arguments.
    */
   public A sum(final A a1, final A a2) {
-    return sum.f(a1).f(a2);
+    return def.append(a1, a2);
   }
 
   /**
@@ -49,7 +113,7 @@ public A sum(final A a1, final A a2) {
    * @return A function that sums the given value according to this semigroup.
    */
   public F<A, A> sum(final A a1) {
-    return sum.f(a1);
+    return def.prepend(a1);
   }
 
   /**
@@ -58,7 +122,7 @@ public F<A, A> sum(final A a1) {
    * @return A function that sums according to this semigroup.
    */
   public F<A, F<A, A>> sum() {
-    return sum;
+    return def::prepend;
   }
 
   /**
@@ -73,106 +137,213 @@ public F<A, F<A, A>> sum() {
    * {@code zero()}
    */
   public A multiply1p(int n, A a) {
-    return multiply1p(sum, n, a);
+    return def.multiply1p(n, a);
   }
 
-  // shared implementation between Semigroup and Monoid
-  static <A> A multiply1p(F<A, F<A, A>> sum, int n, A a) {
-    if (n <= 0) {
-      return a;
-    }
-
-    A xTmp = a;
-    int yTmp = n;
-    A zTmp = a;
-    while (true) {
-      if ((yTmp & 1) == 1) {
-        zTmp = sum.f(xTmp).f(zTmp);
-        if (yTmp == 1) {
-          return zTmp;
-        }
-      }
-      xTmp = sum.f(xTmp).f(xTmp);
-      yTmp = yTmp >>> 1;
-    }
-  }
 
   /**
    * Sums the given values with left-fold.
    */
   public A sumNel(final NonEmptyList<A> as) {
-    return as.foldLeft1(sum);
+    return as.foldLeft1(def::append);
+  }
+
+  /**
+   * Sums the given values with left-fold, shortcutting the computation as early as possible.
+   */
+  public A sumStream(A a, F0<Stream<A>> as) {
+    return def.sum(a, as);
   }
 
   /**
    * Swaps the arguments when summing.
    */
   public Semigroup<A> dual() {
-    return semigroup(flip(sum));
+    return semigroupDef(def.dual());
   }
 
   /**
    * Lifts the semigroup to obtain a trivial monoid.
    */
   public Monoid<Option<A>> lift() {
-    return Monoid.monoid(a -> b -> Option.liftM2(sum).f(a).f(b).orElse(a).orElse(b), Option.none());
+    Definition<A> def = this.def;
+    return monoidDef(new Monoid.Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a1.liftM2(a1, def::append).orElse(a1).orElse(a2);
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> oa) {
+        return n > 0 ? oa.map(a -> def.multiply1p(n - 1, a)) : none();
+      }
+
+      @Override
+      public Option<A> sum(F0<Stream<Option<A>>> oas) {
+        Stream<A> as = oas.f().bind(Option::toStream);
+        return as.uncons(none(), h -> tail ->  some(def.sum(h, tail::_1)));
+      }
+    });
+  }
+
+  /**
+   * Maps the given functions across this monoid as an invariant functor.
+   *
+   * @param f The covariant map.
+   * @param g The contra-variant map.
+   * @return A new monoid.
+   */
+  public <B> Semigroup<B> xmap(final F<A, B> f, final F<B, A> g) {
+    Definition<A> def = this.def;
+    return semigroupDef(new Definition<B>() {
+
+      @Override
+      public B append(B a1, B a2) {
+        return f.f(def.append(g.f(a1), g.f(a2)));
+      }
+
+      @Override
+      public F<B, B> prepend(B b) {
+        return dimap(def.prepend(g.f(b)), g, f);
+      }
+
+      @Override
+      public B multiply1p(int n, B b) {
+        return f.f(def.multiply1p(n , g.f(b)));
+      }
+
+      @Override
+      public B sum(B b, F0<Stream<B>> bs) {
+        return f.f(def.sum(g.f(b), () -> bs.f().map(g)));
+      }
+    });
+  }
+
+  public <B, C> Semigroup<C> compose(Semigroup<B> sb, final F<C, B> b, final F<C, A> a, final F2<A, B, C> c) {
+    Definition<A> saDef = this.def;
+    Definition<B> sbDef = sb.def;
+    return semigroupDef(new Definition<C>() {
+
+      @Override
+      public C append(C c1, C c2) {
+        return c.f(saDef.append(a.f(c1), a.f(c2)), sbDef.append(b.f(c1), b.f(c2)));
+      }
+
+      @Override
+      public F<C, C> prepend(C c1) {
+        F<A, A> prependA = saDef.prepend(a.f(c1));
+        F<B, B> prependB = sbDef.prepend(b.f(c1));
+        return c2 -> c.f(prependA.f(a.f(c2)), prependB.f(b.f(c2)));
+      }
+
+      @Override
+      public C multiply1p(int n, C c1) {
+        return c.f(saDef.multiply1p(n, a.f(c1)), sbDef.multiply1p(n, b.f(c1)));
+      }
+
+      @Override
+      public C sum(C c1, F0<Stream<C>> cs) {
+        return c.f(saDef.sum(a.f(c1), () -> cs.f().map(a)), sbDef.sum(b.f(c1), () -> cs.f().map(b)));
+      }
+    });
+  }
+
+  /**
+   * Constructs a monoid from this semigroup and a zero value, which must follow the monoidal laws.
+   *
+   * @param zero The zero for the monoid.
+   * @return A monoid instance that uses the given sun function and zero value.
+   */
+  public Monoid<A> monoid(A zero) {
+    return monoidDef(this.def, zero);
+  }
+
+  /**
+   * Constructs a semigroup from the given definition.
+   *
+   * @param def The definition to construct this semigroup with.
+   * @return A semigroup from the given definition.
+   */
+  public static <A> Semigroup<A> semigroupDef(final Definition<A> def) {
+    return new Semigroup<>(def);
+  }
+
+  /**
+   * Constructs a semigroup from the given definition.
+   *
+   * @param def The definition to construct this semigroup with.
+   * @return A semigroup from the given definition.
+   */
+  public static <A> Semigroup<A> semigroupDef(final AltDefinition<A> def) {
+    return new Semigroup<>(def);
   }
 
   /**
    * Constructs a semigroup from the given function.
+   * @deprecated since 4.7. Use {@link #semigroupDef(Definition)}.
    *
    * @param sum The function to construct this semigroup with.
    * @return A semigroup from the given function.
    */
+  @Deprecated
   public static <A> Semigroup<A> semigroup(final F<A, F<A, A>> sum) {
-    return new Semigroup<>(sum);
+    return semigroupDef(sum::f);
   }
 
   /**
    * Constructs a semigroup from the given function.
+   * @deprecated since 4.7. Use {@link #semigroupDef(Definition)}.
    *
    * @param sum The function to construct this semigroup with.
    * @return A semigroup from the given function.
    */
+  @Deprecated
   public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
-    return new Semigroup<>(curry(sum));
+    return new Semigroup<>(sum::f);
   }
 
+
   /**
    * A semigroup that adds integers.
    */
-  public static final Semigroup<Integer> intAdditionSemigroup = semigroup((i1, i2) -> i1 + i2);
+  public static final Semigroup<Integer> intAdditionSemigroup = intAdditionMonoid.semigroup();
 
   /**
-   * A semigroup that adds doubles.
+   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
    */
-  public static final Semigroup<Double> doubleAdditionSemigroup = semigroup((d1, d2) -> d1 + d2);
+  @Deprecated
+  public static final Semigroup<Double> doubleAdditionSemigroup = semigroupDef((d1, d2) -> d1 + d2);
 
   /**
    * A semigroup that multiplies integers.
    */
-  public static final Semigroup<Integer> intMultiplicationSemigroup = semigroup((i1, i2) -> i1 * i2);
+  public static final Semigroup<Integer> intMultiplicationSemigroup = intMultiplicationMonoid.semigroup();
 
   /**
-   * A semigroup that multiplies doubles.
+   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
    */
-  public static final Semigroup<Double> doubleMultiplicationSemigroup = semigroup((d1, d2) -> d1 * d2);
+  @Deprecated
+  public static final Semigroup<Double> doubleMultiplicationSemigroup = semigroupDef((d1, d2) -> d1 * d2);
 
   /**
    * A semigroup that yields the maximum of integers.
    */
-  public static final Semigroup<Integer> intMaximumSemigroup = Ord.intOrd.maxSemigroup();
+  public static final Semigroup<Integer> intMaximumSemigroup = intMaxMonoid.semigroup();
 
   /**
    * A semigroup that yields the minimum of integers.
    */
-  public static final Semigroup<Integer> intMinimumSemigroup = Ord.intOrd.minSemigroup();
+  public static final Semigroup<Integer> intMinimumSemigroup = intMinMonoid.semigroup();
 
   /**
    * A semigroup that adds big integers.
    */
-  public static final Semigroup<BigInteger> bigintAdditionSemigroup =
-      semigroup(BigInteger::add);
+  public static final Semigroup<BigInteger> bigintAdditionSemigroup = bigintAdditionMonoid.semigroup();
 
   /**
    * A semigroup that multiplies big integers.
@@ -193,14 +364,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that adds big decimals.
    */
-  public static final Semigroup<BigDecimal> bigdecimalAdditionSemigroup =
-      semigroup(BigDecimal::add);
+  public static final Semigroup<BigDecimal> bigdecimalAdditionSemigroup = bigdecimalAdditionMonoid.semigroup();
 
   /**
    * A semigroup that multiplies big decimals.
    */
-  public static final Semigroup<BigDecimal> bigdecimalMultiplicationSemigroup =
-      semigroup(BigDecimal::multiply);
+  public static final Semigroup<BigDecimal> bigdecimalMultiplicationSemigroup = bigdecimalMultiplicationMonoid.semigroup();
 
   /**
    * A semigroup that yields the maximum of big decimals.
@@ -215,14 +384,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that multiplies natural numbers.
    */
-  public static final Semigroup<Natural> naturalMultiplicationSemigroup =
-      semigroup(Natural::multiply);
+  public static final Semigroup<Natural> naturalMultiplicationSemigroup = naturalMultiplicationMonoid.semigroup();
 
   /**
    * A semigroup that adds natural numbers.
    */
-  public static final Semigroup<Natural> naturalAdditionSemigroup =
-      semigroup(Natural::add);
+  public static final Semigroup<Natural> naturalAdditionSemigroup = naturalAdditionMonoid.semigroup();
 
   /**
    * A semigroup that yields the maximum of natural numbers.
@@ -237,12 +404,12 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that adds longs.
    */
-  public static final Semigroup<Long> longAdditionSemigroup = semigroup((x, y) -> x + y);
+  public static final Semigroup<Long> longAdditionSemigroup = longAdditionMonoid.semigroup();
 
   /**
    * A semigroup that multiplies longs.
    */
-  public static final Semigroup<Long> longMultiplicationSemigroup = semigroup((x, y) -> x * y);
+  public static final Semigroup<Long> longMultiplicationSemigroup = longMultiplicationMonoid.semigroup();
 
   /**
    * A semigroup that yields the maximum of longs.
@@ -257,47 +424,80 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
   /**
    * A semigroup that ORs booleans.
    */
-  public static final Semigroup<Boolean> disjunctionSemigroup = semigroup((b1, b2) -> b1 || b2);
+  public static final Semigroup<Boolean> disjunctionSemigroup = disjunctionMonoid.semigroup();
 
   /**
    * A semigroup that XORs booleans.
    */
-  public static final Semigroup<Boolean> exclusiveDisjunctionSemiGroup = semigroup((p, q) -> p ? !q : q);
+  public static final Semigroup<Boolean> exclusiveDisjunctionSemiGroup = exclusiveDisjunctionMonoid.semigroup();
 
   /**
    * A semigroup that ANDs booleans.
    */
-  public static final Semigroup<Boolean> conjunctionSemigroup = semigroup((b1, b2) -> b1 && b2);
+  public static final Semigroup<Boolean> conjunctionSemigroup = conjunctionMonoid.semigroup();
 
   /**
    * A semigroup that appends strings.
    */
-  public static final Semigroup<String> stringSemigroup = semigroup((s1, s2) -> s1 + s2);
+  public static final Semigroup<String> stringSemigroup = stringMonoid.semigroup();
 
   /**
    * A semigroup that appends string buffers.
    */
-  public static final Semigroup<StringBuffer> stringBufferSemigroup =
-      semigroup((s1, s2) -> new StringBuffer(s1).append(s2));
+  public static final Semigroup<StringBuffer> stringBufferSemigroup = stringBufferMonoid.semigroup();
 
   /**
    * A semigroup that appends string builders.
    */
-  public static final Semigroup<StringBuilder> stringBuilderSemigroup =
-      semigroup((s1, s2) -> new StringBuilder(s1).append(s2));
+  public static final Semigroup<StringBuilder> stringBuilderSemigroup = stringBuilderMonoid.semigroup();
 
   /**
    * A semigroup which always uses the "first" (left-hand side) value.
    */
   public static <A> Semigroup<A> firstSemigroup() {
-      return semigroup((a1, a2) -> a1);
+      return semigroupDef(new Definition<A>() {
+        @Override
+        public A append(A a1, A a2) {
+          return a1;
+        }
+
+        @Override
+        public F<A, A> prepend(A a) {
+          return constant(a);
+        }
+
+        @Override
+        public A multiply1p(int n, A a) {
+          return a;
+        }
+
+        @Override
+        public A sum(A a, F0<Stream<A>> as) {
+          return a;
+        }
+      });
   }
 
   /**
    * A semigroup which always uses the "last" (right-hand side) value.
    */
   public static <A> Semigroup<A> lastSemigroup() {
-    return semigroup((a1, a2) -> a2);
+    return semigroupDef(new Definition<A>() {
+      @Override
+      public A append(A a1, A a2) {
+        return a2;
+      }
+
+      @Override
+      public F<A, A> prepend(A a) {
+        return identity();
+      }
+
+      @Override
+      public A multiply1p(int n, A a) {
+        return a;
+      }
+    });
   }
 
   /**
@@ -307,7 +507,8 @@ public static <A> Semigroup<A> lastSemigroup() {
    * @return A semigroup for functions.
    */
   public static <A, B> Semigroup<F<A, B>> functionSemigroup(final Semigroup<B> sb) {
-    return semigroup((a1, a2) -> a -> sb.sum(a1.f(a), a2.f(a)));
+    Definition<B> sbDef = sb.def;
+    return semigroupDef((a1, a2) -> a -> sbDef.append(a1.f(a), a2.f(a)));
   }
 
   /**
@@ -316,7 +517,7 @@ public static <A, B> Semigroup<F<A, B>> functionSemigroup(final Semigroup<B> sb)
    * @return A semigroup for lists.
    */
   public static <A> Semigroup<List<A>> listSemigroup() {
-    return semigroup(List::append);
+    return Monoid.<A>listMonoid().semigroup();
   }
 
   /**
@@ -325,15 +526,29 @@ public static <A> Semigroup<List<A>> listSemigroup() {
    * @return A semigroup for non-empty lists.
    */
   public static <A> Semigroup<NonEmptyList<A>> nonEmptyListSemigroup() {
-    return semigroup(NonEmptyList::append);
+
+    return semigroupDef(new Definition<NonEmptyList<A>>() {
+      @Override
+      public NonEmptyList<A> append(NonEmptyList<A> a1, NonEmptyList<A> a2) {
+        return a1.append(a1);
+      }
+
+      @Override
+      public NonEmptyList<A> sum(NonEmptyList<A> nea, F0<Stream<NonEmptyList<A>>> neas) {
+        List<A> tail = neas.f().map(nel -> listDList(nel.toList())).foldLeft(DList::append, DList.<A>nil()).run();
+        return nea.append(tail);
+      }
+    });
   }
 
   /**
    * A semigroup for optional values.
+   * @deprecated since 4.7. Use {@link #firstOptionSemigroup()}.
+   *
    ** @return A semigroup for optional values.
    */
   public static <A> Semigroup<Option<A>> optionSemigroup() {
-    return semigroup((a1, a2) -> a1.isSome() ? a1 : a2);
+    return firstOptionSemigroup();
   }
 
   /**
@@ -342,7 +557,7 @@ public static <A> Semigroup<Option<A>> optionSemigroup() {
    * @return A semigroup for optional values that take the first available value.
    */
   public static <A> Semigroup<Option<A>> firstOptionSemigroup() {
-    return semigroup((a1, a2) -> a1.orElse(a2));
+    return Monoid.<A>firstOptionMonoid().semigroup();
   }
 
   /**
@@ -351,7 +566,7 @@ public static <A> Semigroup<Option<A>> firstOptionSemigroup() {
    * @return A semigroup for optional values that take the last available value.
    */
   public static <A> Semigroup<Option<A>> lastOptionSemigroup() {
-    return semigroup((a1, a2) -> a2.orElse(a1));
+    return Monoid.<A>lastOptionMonoid().semigroup();
   }
 
   /**
@@ -360,7 +575,7 @@ public static <A> Semigroup<Option<A>> lastOptionSemigroup() {
    * @return A semigroup for streams.
    */
   public static <A> Semigroup<Stream<A>> streamSemigroup() {
-    return semigroup((a1, a2) -> a1.append(a2));
+    return Monoid.<A>streamMonoid().semigroup();
   }
 
   /**
@@ -369,41 +584,58 @@ public static <A> Semigroup<Stream<A>> streamSemigroup() {
    * @return A semigroup for arrays.
    */
   public static <A> Semigroup<Array<A>> arraySemigroup() {
-    return semigroup(Array::append);
+    return Monoid.<A>arrayMonoid().semigroup();
   }
 
   /**
-   * A semigroup for unary products.
+   * A lazy semigroup for unary products.
    *
    * @param sa A semigroup for the product's type.
    * @return A semigroup for unary products.
    */
   public static <A> Semigroup<P1<A>> p1Semigroup(final Semigroup<A> sa) {
-    return semigroup((a1, a2) -> P.lazy(() -> sa.sum(a1._1(), a2._1())));
+    Definition<A> def = sa.def;
+    return semigroupDef(new Definition<P1<A>>() {
+      @Override
+      public P1<A> append(P1<A> a1, P1<A> a2) {
+        return P.lazy(() -> def.append(a1._1(), a2._1()));
+      }
+
+      @Override
+      public P1<A> multiply1p(int n, P1<A> ap1) {
+        return P.lazy(() -> def.multiply1p(n, ap1._1()));
+      }
+
+      @Override
+      public P1<A> sum(P1<A> ap1, F0<Stream<P1<A>>> as) {
+        return P.lazy(() -> def.sum(ap1._1(), () -> as.f().map(P1.__1())));
+      }
+    });
   }
 
   /**
-   * A semigroup for binary products.
+   * A lazy semigroup for binary products.
    *
    * @param sa A semigroup for the product's first type.
    * @param sb A semigroup for the product's second type.
    * @return A semigroup for binary products.
    */
   public static <A, B> Semigroup<P2<A, B>> p2Semigroup(final Semigroup<A> sa, final Semigroup<B> sb) {
-    return semigroup((a1, a2) -> P.lazy(() -> sa.sum(a1._1(), a2._1()), () -> sb.sum(a1._2(), a2._2())));
+    return semigroupDef((a1, a2) -> P.lazy(() -> sa.sum(a1._1(), a2._1()), () -> sb.sum(a1._2(), a2._2())));
   }
 
   /**
    * A semigroup for IO values.
    */
   public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
-      return semigroup((a1, a2) -> IOFunctions.liftM2(a1, a2, sa::sum));
+    Definition<A> def = sa.def;
+    return semigroupDef((a1, a2) -> () -> def.append(a1.run(), a2.run()));
   }
 
   /**
    * A semigroup for the Unit value.
    */
-  public static final Semigroup<Unit> unitSemigroup = semigroup((u1, u2) -> Unit.unit());
+  public static final Semigroup<Unit> unitSemigroup = unitMonoid.semigroup();
 
   /**
    * A semigroup for sets.
@@ -411,7 +643,7 @@ public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
    * @return a semigroup for sets.
    */
   public static <A> Semigroup<Set<A>> setSemigroup() {
-    return semigroup(Set::union);
+    return semigroupDef(Set::union);
   }
 
 }
diff --git a/core/src/main/java/fj/data/optic/Fold.java b/core/src/main/java/fj/data/optic/Fold.java
index af6b5739..691c779c 100644
--- a/core/src/main/java/fj/data/optic/Fold.java
+++ b/core/src/main/java/fj/data/optic/Fold.java
@@ -39,7 +39,7 @@ public final List<A> getAll(final S s) {
 
   /** find the first target of a {@link Fold} matching the predicate */
   public final F<S, Option<A>> find(final F<A, Boolean> p) {
-    return foldMap(Monoid.optionMonoid(), a -> p.f(a) ? Option.some(a) : Option.none());
+    return foldMap(Monoid.firstOptionMonoid(), a -> p.f(a) ? Option.some(a) : Option.none());
   }
 
   /** get the first target of a {@link Fold} */
diff --git a/core/src/main/java/fj/data/optic/PTraversal.java b/core/src/main/java/fj/data/optic/PTraversal.java
index 50c1e14c..dbd8b0cd 100644
--- a/core/src/main/java/fj/data/optic/PTraversal.java
+++ b/core/src/main/java/fj/data/optic/PTraversal.java
@@ -104,7 +104,7 @@ public final List<A> getAll(final S s) {
 
   /** find the first target of a {@link PTraversal} matching the predicate */
   public final F<S, Option<A>> find(final F<A, Boolean> p) {
-    return foldMap(Monoid.optionMonoid(), a -> p.f(a) ? Option.some(a) : Option.none());
+    return foldMap(Monoid.firstOptionMonoid(), a -> p.f(a) ? Option.some(a) : Option.none());
   }
 
   /** get the first target of a {@link PTraversal} */
diff --git a/core/src/main/java/fj/function/Doubles.java b/core/src/main/java/fj/function/Doubles.java
index 7bff2409..6fe1b033 100644
--- a/core/src/main/java/fj/function/Doubles.java
+++ b/core/src/main/java/fj/function/Doubles.java
@@ -6,11 +6,8 @@
 import fj.data.Option;
 
 import static fj.Function.curry;
-import static fj.Semigroup.doubleAdditionSemigroup;
-import static fj.Semigroup.doubleMultiplicationSemigroup;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
-import static java.lang.Math.abs;
 
 /**
  * Curried functions over Doubles.
@@ -25,17 +22,17 @@ private Doubles() {
   /**
    * Curried Double addition.
    */
-  public static final F<Double, F<Double, Double>> add = doubleAdditionSemigroup.sum();
+  public static final F<Double, F<Double, Double>> add = x -> y -> x + y;
 
   /**
    * Curried Double multiplication.
    */
-  public static final F<Double, F<Double, Double>> multiply = doubleMultiplicationSemigroup.sum();
+  public static final F<Double, F<Double, Double>> multiply = x -> y -> x * y;
 
   /**
    * Curried Double subtraction.
    */
-  public static final F<Double, F<Double, Double>> subtract = curry((x, y) -> x - y);
+  public static final F<Double, F<Double, Double>> subtract = x -> y -> x - y;
 
   /**
    * Negation.
@@ -50,12 +47,12 @@ private Doubles() {
   /**
    * Remainder.
    */
-  public static final F<Double, F<Double, Double>> remainder = curry((a, b) -> a % b);
+  public static final F<Double, F<Double, Double>> remainder = x -> y -> x % y;
 
   /**
    * Power.
    */
-  public static final F<Double, F<Double, Double>> power = curry(StrictMath::pow);
+  public static final F<Double, F<Double, Double>> power = x -> y -> StrictMath.pow(x, y);
 
   /**
    * Evenness.
@@ -69,7 +66,7 @@ private Doubles() {
    * @return The sum of the doubless in the list.
    */
   public static double sum(final List<Double> doubles) {
-    return Monoid.doubleAdditionMonoid.sumLeft(doubles);
+    return doubles.foldLeft((x, y) -> x + y, 0.0);
   }
 
   /**
@@ -79,7 +76,7 @@ public static double sum(final List<Double> doubles) {
    * @return The product of the doubles in the list.
    */
   public static double product(final List<Double> doubles) {
-    return Monoid.doubleMultiplicationMonoid.sumLeft(doubles);
+    return doubles.foldLeft((x, y) -> x * y, 1.0);
   }
 
   /**
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index 203b8feb..c90a0b2d 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -1,6 +1,7 @@
 package fj.demo.concurrent;
 
 import static fj.Monoid.monoid;
+import static fj.Monoid.monoidDef;
 import static fj.control.parallel.ParModule.parModule;
 import static fj.data.List.nil;
 import static java.util.concurrent.Executors.newFixedThreadPool;
@@ -14,6 +15,7 @@
 import java.io.StringWriter;
 import java.io.Writer;
 import java.nio.charset.Charset;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
@@ -307,10 +309,7 @@ public static Map<String, Integer> getWordsAndCountsFromFilesInParallel(
   // Read documents and extract words and word counts of documents
   public static Promise<Map<String, Integer>> getWordsAndCountsFromFiles(
       final List<String> fileNames, final F<String, Map<String, Integer>> fileNameToWordsAndCounts, final ParModule m) {
-    final F<Map<String, Integer>, F<Map<String, Integer>, Map<String, Integer>>> MapSum =
-        a -> b -> plus(a, b);
-    final Monoid<Map<String, Integer>> monoid = monoid(MapSum,
-        new HashMap<String, Integer>());
+    final Monoid<Map<String, Integer>> monoid = monoidDef(WordCount::plus, Collections.emptyMap());
     return m.parFoldMap(fileNames, fileNameToWordsAndCounts, monoid);
   }
   

From 1970c3e04db3dcadaaa6b33accc3ff2cffc16358 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 26 Sep 2016 21:24:07 +0200
Subject: [PATCH 143/336] use more method references. make Stream conversions
 respect laziness. optimize collectors.

---
 java8/src/main/java/fj/data/Collectors.java |  4 +-
 java8/src/main/java/fj/data/Java8.java      | 49 +++++++++++----------
 2 files changed, 27 insertions(+), 26 deletions(-)

diff --git a/java8/src/main/java/fj/data/Collectors.java b/java8/src/main/java/fj/data/Collectors.java
index 3f3d7e40..5ee9ead6 100644
--- a/java8/src/main/java/fj/data/Collectors.java
+++ b/java8/src/main/java/fj/data/Collectors.java
@@ -21,7 +21,7 @@ public static <A> Collector<A, List.Buffer<A>, Array<A>> toArray() {
         List.Buffer::new,
         List.Buffer::snoc,
         (acc1, acc2) -> acc1.append(acc2.toList()),
-        (buf) -> Array.iterableArray(buf.toList())
+        (buf) -> buf.toList().toArray()
     );
   }
 
@@ -30,7 +30,7 @@ public static <A> Collector<A, List.Buffer<A>, Stream<A>> toStream() {
         List.Buffer::new,
         List.Buffer::snoc,
         (acc1, acc2) -> acc1.append(acc2.toList()),
-        (buf) -> Stream.iterableStream(buf.toList())
+        (buf) -> buf.toList().toStream()
     );
   }
 }
diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
index be776822..d2d23fb2 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/java8/src/main/java/fj/data/Java8.java
@@ -2,6 +2,7 @@
 
 import java.util.Iterator;
 import java.util.Optional;
+import java.util.Spliterators;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -28,75 +29,75 @@ private Java8() {
     }
 
     public static <A> P1<A> Supplier_P1(final Supplier<A> s) {
-        return Java8.<A>Supplier_P1().f(s);
+        return P.lazy(s::get);
     }
 
     public static <A> F<Supplier<A>, P1<A>> Supplier_P1() {
-        return s -> P.lazy(s::get);
+        return Java8::Supplier_P1;
     }
 
     public static <A> Supplier<A> P1_Supplier(final P1<A> p) {
-        return Java8.<A>P1_Supplier().f(p);
+        return p::_1;
     }
 
     public static <A> F<P1<A>, Supplier<A>> P1_Supplier() {
-        return (p) -> p::_1;
+        return Java8::P1_Supplier;
     }
 
     public static <A, B> F<A, B> Function_F(final Function<A, B> f) {
-        return Java8.<A, B>Function_F().f(f);
+        return f::apply;
     }
 
     public static <A, B> F<Function<A, B>, F<A, B>> Function_F() {
-        return f -> f::apply;
+        return Java8::Function_F;
     }
 
     public static <A, B> Function<A, B> F_Function(final F<A, B> f) {
-        return Java8.<A, B>F_Function().f(f);
+        return f::f;
     }
 
     public static <A, B> F<F<A, B>, Function<A, B>> F_Function() {
-        return f -> f::f;
+        return Java8::F_Function;
     }
 
     public static <A, B, C> F2<A, B, C> BiFunction_F2(final BiFunction<A, B, C> f) {
-        return Java8.<A, B, C>BiFunction_F2().f(f);
+        return f::apply;
     }
 
     public static <A, B, C> F<BiFunction<A, B, C>, F2<A, B, C>> BiFunction_F2() {
-        return f -> f::apply;
+        return Java8::BiFunction_F2;
     }
 
     public static <A, B, C> BiFunction<A, B, C> F2_BiFunction(final F2<A, B, C> f) {
-        return Java8.<A, B, C>F2_BiFunction().f(f);
+        return f::f;
     }
 
     public static <A, B, C> F<F2<A, B, C>, BiFunction<A, B, C>> F2_BiFunction() {
-        return f -> f::f;
+        return Java8::F2_BiFunction;
     }
 
     public static <A, E extends Exception> Supplier<Validation<E, A>> TryCatch0_Supplier(final Try0<A, E> t) {
-        return Java8.<A, E>TryCatch0_Supplier().f(t);
+        return () -> Try.f(t)._1();
     }
 
     public static <A, E extends Exception> F<Try0<A, E>, Supplier<Validation<E, A>>> TryCatch0_Supplier() {
-        return t -> () -> Try.f(t)._1();
+        return Java8::TryCatch0_Supplier;
     }
 
     public static <A, B, E extends Exception> Function<A, Validation<E, B>> TryCatch1_Function(final Try1<A, B, E> t) {
-        return Java8.<A, B, E>TryCatch1_Function().f(t);
+        return a -> Try.f(t).f(a);
     }
 
     public static <A, B, E extends Exception> F<Try1<A, B, E>, Function<A, Validation<E, B>>> TryCatch1_Function() {
-        return t -> a -> Try.f(t).f(a);
+        return Java8::TryCatch1_Function;
     }
 
     public static <A, B, C, E extends Exception> BiFunction<A, B, Validation<E, C>> TryCatch2_BiFunction(final Try2<A, B, C, E> t) {
-        return Java8.<A, B, C, E>TryCatch2_BiFunction().f(t);
+        return (a, b) -> Try.f(t).f(a, b);
     }
 
     public static <A, B, C, E extends Exception> F<Try2<A, B, C, E>, BiFunction<A, B, Validation<E, C>>> TryCatch2_BiFunction() {
-        return t -> (a, b) -> Try.f(t).f(a, b);
+        return Java8::TryCatch2_BiFunction;
     }
 
     public static <A> java.util.stream.Stream<A> List_JavaStream(final List<A> list) {
@@ -104,19 +105,19 @@ public static <A> java.util.stream.Stream<A> List_JavaStream(final List<A> list)
     }
 
     public static <A> Option<A> Optional_Option(final Optional<A> o) {
-        return Java8.<A>Optional_Option().f(o);
+        return o.isPresent() ? Option.some(o.get()) : Option.none();
     }
 
     public static <A> F<Optional<A>, Option<A>> Optional_Option() {
-        return o -> o.isPresent() ? Option.some(o.get()) : Option.none();
+        return Java8::Optional_Option;
     }
 
     public static <A> Optional<A> Option_Optional(final Option<A> o) {
-        return Java8.<A>Option_Optional().f(o);
+        return o.option(Optional.empty(), Optional::ofNullable);
     }
 
     public static <A> F<Option<A>, Optional<A>> Option_Optional() {
-        return o -> o.isSome() ? Optional.ofNullable(o.some()) : Optional.empty();
+        return Java8::Option_Optional;
     }
 
     public static <A> F<Consumer<A>, F<A, Unit>> Consumer_F() {
@@ -139,7 +140,7 @@ public static <A> java.util.stream.Stream<A> Iterable_JavaStream(final Iterable<
     }
 
     public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<A> it) {
-        return Iterable_JavaStream(() -> it);
+        return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false);
     }
 
     public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
@@ -147,7 +148,7 @@ public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaSt
     }
 
     public static <A> Stream<A> JavaStream_Stream(final java.util.stream.Stream<A> s) {
-        return s.collect(Collectors.toStream());
+        return Stream.iteratorStream(s.iterator());
     }
 
     public static <A> List<A> JavaStream_List(final java.util.stream.Stream<A> s) {

From a8f9db4320e78f459525a96fa6e7ff3b3da7f94a Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 10:38:28 +0200
Subject: [PATCH 144/336] Java8 converter: Do not silently convert
 Option.some(null) to Optional.absent() Let's not try to cover for Optional
 mistakes. Otherwise bugs will silently happen.

---
 java8/src/main/java/fj/data/Java8.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/java8/src/main/java/fj/data/Java8.java b/java8/src/main/java/fj/data/Java8.java
index d2d23fb2..e41f0958 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/java8/src/main/java/fj/data/Java8.java
@@ -112,8 +112,11 @@ public static <A> F<Optional<A>, Option<A>> Optional_Option() {
         return Java8::Optional_Option;
     }
 
+    /**
+     * Convert an Option to {@link Optional}. Will throw a {@link NullPointerException} if the Option is some(null).
+     */
     public static <A> Optional<A> Option_Optional(final Option<A> o) {
-        return o.option(Optional.empty(), Optional::ofNullable);
+        return o.option(Optional.empty(), Optional::of);
     }
 
     public static <A> F<Option<A>, Optional<A>> Option_Optional() {

From 9c28f6f19cc383bf660ac0d4d1c441123313b372 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Thu, 15 Sep 2016 21:05:17 +0200
Subject: [PATCH 145/336] Fix #287: Add semigroup constraint to
 List.traverseValidation for now implement traverse from sequence.  (but the
 other way around would be better)

---
 core/src/main/java/fj/data/List.java          | 11 ++++-----
 core/src/main/java/fj/data/optic/PIso.java    |  3 ++-
 core/src/main/java/fj/data/optic/PLens.java   |  3 ++-
 .../main/java/fj/data/optic/POptional.java    |  3 ++-
 core/src/main/java/fj/data/optic/PPrism.java  |  3 ++-
 .../main/java/fj/data/optic/PTraversal.java   | 23 ++++++++++---------
 .../main/java/fj/data/optic/Traversal.java    |  5 ++--
 7 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index a4fa19eb..07b21862 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -10,6 +10,7 @@
 import fj.Ordering;
 import fj.P;
 import fj.P1;
+import fj.Semigroup;
 import fj.Show;
 import fj.Unit;
 import fj.P2;
@@ -676,10 +677,8 @@ public final <B> List<List<B>> traverseList(final F<A, List<B>> f) {
         single(List.nil()));
   }
 
-  public final <E, B> Validation<E, List<B>> traverseValidation(final F<A, Validation<E, B>> f) {
-    return foldRight(
-        (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        Validation.success(List.nil()));
+  public final <E, B> Validation<E, List<B>> traverseValidation(Semigroup<E> s, final F<A, Validation<E, B>> f) {
+    return Validation.sequence(s, map(f));
   }
 
   public final <B> V2<List<B>> traverseV2(final F<A, V2<B>> f) {
@@ -2166,8 +2165,8 @@ public F<List<A>, P1<List<B>>> modifyP1F(F<A, P1<B>> f) {
         }
 
         @Override
-        public <E> F<List<A>, Validation<E, List<B>>> modifyValidationF(F<A, Validation<E, B>> f) {
-          return l -> l.traverseValidation(f);
+        public <E> F<List<A>, Validation<E, List<B>>> modifyValidationF(Semigroup<E> s, F<A, Validation<E, B>> f) {
+          return l -> l.traverseValidation(s, f);
         }
 
         @Override
diff --git a/core/src/main/java/fj/data/optic/PIso.java b/core/src/main/java/fj/data/optic/PIso.java
index 7dcd0888..e10b47bb 100644
--- a/core/src/main/java/fj/data/optic/PIso.java
+++ b/core/src/main/java/fj/data/optic/PIso.java
@@ -6,6 +6,7 @@
 import fj.P;
 import fj.P1;
 import fj.P2;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.data.Either;
@@ -314,7 +315,7 @@ public F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, final F<A, Validation<E, B>> f) {
         return self.modifyValidationF(f);
       }
 
diff --git a/core/src/main/java/fj/data/optic/PLens.java b/core/src/main/java/fj/data/optic/PLens.java
index 68de9079..971f76ff 100644
--- a/core/src/main/java/fj/data/optic/PLens.java
+++ b/core/src/main/java/fj/data/optic/PLens.java
@@ -4,6 +4,7 @@
 import fj.Function;
 import fj.Monoid;
 import fj.P1;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.data.Either;
@@ -320,7 +321,7 @@ public F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, final F<A, Validation<E, B>> f) {
         return self.modifyValidationF(f);
       }
 
diff --git a/core/src/main/java/fj/data/optic/POptional.java b/core/src/main/java/fj/data/optic/POptional.java
index 73cc6fe9..d35979d8 100644
--- a/core/src/main/java/fj/data/optic/POptional.java
+++ b/core/src/main/java/fj/data/optic/POptional.java
@@ -6,6 +6,7 @@
 import fj.P;
 import fj.P1;
 import fj.P2;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.control.parallel.Strategy;
@@ -345,7 +346,7 @@ public F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, final F<A, Validation<E, B>> f) {
         return self.modifyValidationF(f);
       }
 
diff --git a/core/src/main/java/fj/data/optic/PPrism.java b/core/src/main/java/fj/data/optic/PPrism.java
index f6712989..c4a65a68 100644
--- a/core/src/main/java/fj/data/optic/PPrism.java
+++ b/core/src/main/java/fj/data/optic/PPrism.java
@@ -5,6 +5,7 @@
 import fj.Monoid;
 import fj.P;
 import fj.P1;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.control.parallel.Strategy;
@@ -310,7 +311,7 @@ public F<S, P1<T>> modifyP1F(final F<A, P1<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, final F<A, Validation<E, B>> f) {
         return self.modifyValidationF(f);
       }
 
diff --git a/core/src/main/java/fj/data/optic/PTraversal.java b/core/src/main/java/fj/data/optic/PTraversal.java
index 50c1e14c..6344d4d8 100644
--- a/core/src/main/java/fj/data/optic/PTraversal.java
+++ b/core/src/main/java/fj/data/optic/PTraversal.java
@@ -10,6 +10,7 @@
 import fj.Monoid;
 import fj.P;
 import fj.P1;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.data.Either;
@@ -82,7 +83,7 @@ public abstract class PTraversal<S, T, A, B> {
   /**
    * modify polymorphically the target of a {@link PTraversal} with an Applicative function
    */
-  public abstract <E> F<S, Validation<E, T>> modifyValidationF(F<A, Validation<E, B>> f);
+  public abstract <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, F<A, Validation<E, B>> f);
 
   /**
    * modify polymorphically the target of a {@link PTraversal} with an Applicative function
@@ -218,10 +219,10 @@ public F<Either<S, S1>, V2<Either<T, T1>>> modifyV2F(final F<A, V2<B>> f) {
       }
 
       @Override
-      public <E> F<Either<S, S1>, Validation<E, Either<T, T1>>> modifyValidationF(final F<A, Validation<E, B>> f) {
+      public <E> F<Either<S, S1>, Validation<E, Either<T, T1>>> modifyValidationF(Semigroup<E> se, final F<A, Validation<E, B>> f) {
         return ss1 -> ss1.either(
-            s -> self.modifyValidationF(f).f(s).map(Either.left_()),
-            s1 -> other.modifyValidationF(f).f(s1).map(Either.right_())
+            s -> self.modifyValidationF(se, f).f(s).map(Either.left_()),
+            s1 -> other.modifyValidationF(se, f).f(s1).map(Either.right_())
             );
       }
 
@@ -307,8 +308,8 @@ public F<S, P1<T>> modifyP1F(final F<C, P1<D>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<C, Validation<E, D>> f) {
-        return self.modifyValidationF(other.modifyValidationF(f));
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> s, final F<C, Validation<E, D>> f) {
+        return self.modifyValidationF(s, other.modifyValidationF(s, f));
       }
 
       @Override
@@ -450,7 +451,7 @@ public F<Either<S, S>, V2<Either<T, T>>> modifyV2F(final F<S, V2<T>> f) {
       }
 
       @Override
-      public <E> F<Either<S, S>, Validation<E, Either<T, T>>> modifyValidationF(final F<S, Validation<E, T>> f) {
+      public <E> F<Either<S, S>, Validation<E, Either<T, T>>> modifyValidationF(Semigroup<E> se, final F<S, Validation<E, T>> f) {
         return s -> s.bimap(f, f).either(
             v -> v.map(Either.left_()),
             v -> v.map(Either.right_())
@@ -520,8 +521,8 @@ public F<S, V2<T>> modifyV2F(final F<A, V2<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
-        return s -> f.f(get2.f(s)).apply(f.f(get1.f(s)).<F<B, T>> map(b1 -> b2 -> set.f(b1, b2, s)));
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> se, final F<A, Validation<E, B>> f) {
+        return s -> f.f(get2.f(s)).accumapply(se, f.f(get1.f(s)).<F<B, T>> map(b1 -> b2 -> set.f(b1, b2, s)));
       }
 
       @Override
@@ -611,8 +612,8 @@ public F<S, V2<T>> modifyV2F(final F<A, V2<B>> f) {
       }
 
       @Override
-      public <E> F<S, Validation<E, T>> modifyValidationF(final F<A, Validation<E, B>> f) {
-        return s -> f.f(lastGet.f(s)).apply(curriedTraversal.modifyValidationF(f).f(s));
+      public <E> F<S, Validation<E, T>> modifyValidationF(Semigroup<E> se, final F<A, Validation<E, B>> f) {
+        return s -> f.f(lastGet.f(s)).accumapply(se, curriedTraversal.modifyValidationF(se, f).f(s));
       }
 
       @Override
diff --git a/core/src/main/java/fj/data/optic/Traversal.java b/core/src/main/java/fj/data/optic/Traversal.java
index 4064385e..a1a466d8 100644
--- a/core/src/main/java/fj/data/optic/Traversal.java
+++ b/core/src/main/java/fj/data/optic/Traversal.java
@@ -8,6 +8,7 @@
 import fj.F7;
 import fj.Monoid;
 import fj.P1;
+import fj.Semigroup;
 import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.data.Either;
@@ -72,8 +73,8 @@ public F<S, P1<S>> modifyP1F(final F<A, P1<A>> f) {
   }
 
   @Override
-  public <E> F<S, Validation<E, S>> modifyValidationF(final F<A, Validation<E, A>> f) {
-    return pTraversal.modifyValidationF(f);
+  public <E> F<S, Validation<E, S>> modifyValidationF(Semigroup<E> s, final F<A, Validation<E, A>> f) {
+    return pTraversal.modifyValidationF(s, f);
   }
 
   @Override

From 3ceef52530e378a9b5a61222705c98c267d1254d Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 25 Sep 2016 18:35:35 +0200
Subject: [PATCH 146/336] Convert to property based tests to use runner. add
 test for hardMemo (also, previously, they did not fails the test if a
 property failed.

---
 .../src/test/java/fj/MemoisationTest.java     | 76 +++++++------------
 1 file changed, 28 insertions(+), 48 deletions(-)

diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
index b3c2853b..ac686465 100644
--- a/props-core/src/test/java/fj/MemoisationTest.java
+++ b/props-core/src/test/java/fj/MemoisationTest.java
@@ -1,7 +1,9 @@
 package fj;
 
 import fj.test.Property;
+import fj.test.runner.PropertyTestRunner;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 
 import static fj.test.Arbitrary.arbInteger;
 import static fj.test.CheckResult.summary;
@@ -12,99 +14,77 @@
 /**
  * Created by mperry on 14/07/2014.
  */
+@RunWith(PropertyTestRunner.class)
 public class MemoisationTest {
 
-    @Test
-    public void test1() {
-        final Property p = property(arbInteger, a -> {
-            P1<Integer> t = P.p(a).memo();
-            return prop(t._1() == t._1());
+    public Property test1() {
+        return property(arbInteger, a -> {
+            P1<Integer> t = P.lazy(() -> a).memo();
+            return prop(t._1().equals(t._1())).and(prop(t._1().equals(a)));
         });
-        summary.println(p.check());
     }
 
-    @Test
-    public void test2() {
-        final Property p = property(arbInteger, arbInteger, (a, b) -> {
-            P2<Integer, Integer> t = P.p(a, b).memo();
-            return prop(t._1() == t._1() && t._2() == t._2());
+    public Property test1_hardMemo() {
+        return property(arbInteger, a -> {
+            P1<Integer> t = P.lazy(() -> new Integer(a)).hardMemo();
+            return prop(t._1() == t._1()).and(prop(t._1().equals(a)));
         });
-        summary.println(p.check());
-    }
-
-    static P2<Integer, Integer> pair = P.p(0, 0);
-
-    static Integer count(int i) {
-        if (i == 1) {
-            pair = P.p(pair._1() + 1, pair._2());
-            return pair._1();
-        } else if (i == 2) {
-            pair = P.p(pair._1(), pair._2() + 1);
-            return pair._2();
-        } else {
-            return -1;
-        }
     }
 
     @Test
-    public void testRecomputeP2() {
-        P2<Integer, Integer> t = P.lazy(u -> count(1), u -> count(2)).memo();
-        System.out.println("tuple: " + t + " 1:" + t._1() + " 2: " + t._2());
-        assertTrue(t._1() == t._1() && t._2() == t._2());
+    public Property test2() {
+        return property(arbInteger, arbInteger, (a, b) -> {
+            P2<Integer, Integer> t = P.lazy(u -> new Integer(a), u -> new Integer(b)).memo();
+            return prop(t._1().equals(t._1()) && t._1().equals(a) && t._2().equals(t._2()) && t._2().equals(b) );
+        });
     }
 
     @Test
-    public void test3() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, (a, b, c) -> {
+    public Property test3() {
+        return property(arbInteger, arbInteger, arbInteger, (a, b, c) -> {
             P3<Integer, Integer, Integer> t = P.p(a, b, c).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3());
         });
-        summary.println(p.check());
     }
 
     @Test
-    public void test4() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d) -> {
+    public Property test4() {
+        return property(arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d) -> {
             P4<Integer, Integer, Integer, Integer> t = P.p(a, b, c, d).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3() && t._4() == t._4());
         });
-        summary.println(p.check());
     }
 
     @Test
-    public void test5() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e) -> {
+    public Property test5() {
+        return property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e) -> {
             P5<Integer, Integer, Integer, Integer, Integer> t = P.p(a, b, c, d, e).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3() && t._4() == t._4() && t._5() == t._5());
         });
-        summary.println(p.check());
     }
 
     @Test
-    public void test6() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f) -> {
+    public Property test6() {
+        return property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f) -> {
             P6<Integer, Integer, Integer, Integer, Integer, Integer> t = P.p(a, b, c, d, e, f).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3() && t._4() == t._4() && t._5() == t._5() && t._6() == t._6());
         });
-        summary.println(p.check());
     }
 
     @Test
-    public void test7() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f, g) -> {
+    public Property test7() {
+        return property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f, g) -> {
             P7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> t = P.p(a, b, c, d, e, f, g).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3() && t._4() == t._4() && t._5() == t._5() && t._6() == t._6() && t._7() == t._7());
         });
-        summary.println(p.check());
     }
 
     @Test
-    public void test8() {
-        final Property p = property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f, g, h) -> {
+    public Property test8() {
+        return property(arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, arbInteger, (a, b, c, d, e, f, g, h) -> {
             P8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> t = P.p(a, b, c, d, e, f, g, h).memo();
             return prop(t._1() == t._1() && t._2() == t._2() && t._3() == t._3() && t._4() == t._4() && t._5() == t._5() && t._6() == t._6() && t._7() == t._7() && t._8() == t._8());
         });
-        summary.println(p.check());
     }
 
 }

From ac116dfa81a15e63274adb13463e436a012ae3d1 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 25 Sep 2016 18:45:58 +0200
Subject: [PATCH 147/336] Make _1() method of memoized P1s smaller so that the
 fast path can be inlined by the jvm. Also replaced Option by P1 in
 implementation, also avoid wrapping some more memoized instances.

---
 core/src/main/java/fj/P1.java | 84 +++++++++++++++++++----------------
 1 file changed, 45 insertions(+), 39 deletions(-)

diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 1b36e0a7..cf763f55 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -1,15 +1,17 @@
 package fj;
 
-import java.lang.ref.Reference;
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
-
 import fj.data.Array;
-import fj.data.List;
-import fj.data.Stream;
 import fj.data.Either;
+import fj.data.List;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.data.Validation;
+
+import java.lang.ref.Reference;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+
+import static fj.P.p;
 //import fj.data.*;
 
 
@@ -138,7 +140,7 @@ public final <B, C> P1<C> liftM2(P1<B> pb, F2<A, B, C> f) {
      * @return A single P1 for the given List.
      */
     public static <A> P1<List<A>> sequence(final List<P1<A>> as) {
-        return as.foldRight(liftM2(List.cons()), P.p(List.nil()));
+        return as.foldRight(liftM2(List.cons()), p(List.nil()));
     }
 
     /**
@@ -157,7 +159,7 @@ public static <A> F<List<P1<A>>, P1<List<A>>> sequenceList() {
      * @return A single P1 for the given stream.
      */
     public static <A> P1<Stream<A>> sequence(final Stream<P1<A>> as) {
-        return as.foldRight(liftM2(Stream.cons()), P.p(Stream.nil()));
+        return as.foldRight(liftM2(Stream.cons()), p(Stream.nil()));
     }
 
 	/**
@@ -238,7 +240,7 @@ public final <B> P1<B> map(final F<A, B> f) {
         return P.lazy(() -> f.f(self._1()));
       }
 
-    public P1<A> memo() {
+    public final P1<A> memo() {
         return weakMemo();
     }
 
@@ -247,7 +249,7 @@ public P1<A> memo() {
      *
      * @return A P1 that calls this P1 once and remembers the value for subsequent calls.
      */
-    public final P1<A> hardMemo() { return new Memo<>(this); }
+    public P1<A> hardMemo() { return new Memo<>(this); }
 
     /**
      * Like <code>memo</code>, but the memoized value is wrapped into a <code>WeakReference</code>
@@ -267,65 +269,69 @@ public static <A> P1<A> memo(F0<A> f) {
 		return P.lazy(f).memo();
 	}
 
-    static class Memo<A> extends P1<A> {
+    static final class Memo<A> extends P1<A> {
       private volatile P1<A> self;
       private A value;
 
       Memo(P1<A> self) { this.self = self; }
 
       @Override public final A _1() {
+        return (self == null) ? value : computeValue();
+      }
+
+      private synchronized A computeValue() {
+        P1<A> self = this.self;
         if (self != null) {
-          synchronized (this) {
-            if (self != null) {
-              A a = self._1();
-              value = a;
-              self = null;
-              return a;
-            }
-          }
+          value = self._1();
+          this.self = null;
         }
         return value;
       }
 
-      @Override public final P1<A> memo() { return this; }
+      @Override public P1<A> hardMemo() { return this; }
+      @Override public P1<A> softMemo() { return this; }
+      @Override public P1<A> weakMemo() { return this; }
     }
 
     abstract static class ReferenceMemo<A> extends P1<A> {
       private final P1<A> self;
-      private final Object latch = new Object();
-      private volatile Reference<Option<A>> v = null;
+      private volatile Reference<P1<A>> v = null;
 
       ReferenceMemo(final P1<A> self) { this.self = self; }
 
       @Override public final A _1() {
-        Option<A> o = v != null ? v.get() : null;
-        if (o == null) {
-          synchronized (latch) {
-            o = v != null ? v.get() : null;
-            if (o == null) {
-              o = Option.some(self._1());
-              v = newReference(o);
-            }
-          }
+        Reference<P1<A>> v = this.v;
+        P1<A> p1 = v != null ? v.get() : null;
+        return p1 != null ? p1._1() : computeValue();
+      }
+
+      private synchronized A computeValue() {
+        Reference<P1<A>> v = this.v;
+        P1<A> p1 = v != null ? v.get() : null;
+        if (p1 == null) {
+          A a = self._1();
+          this.v = newReference(p(a));
+          return a;
         }
-        return o.some();
+        return p1._1();
       }
 
-      abstract Reference<Option<A>> newReference(Option<A> o);
+      abstract <B> Reference<B> newReference(B ref);
     }
 
-    static class WeakReferenceMemo<A> extends ReferenceMemo<A> {
+    static final class WeakReferenceMemo<A> extends ReferenceMemo<A> {
       WeakReferenceMemo(P1<A> self) { super(self); }
       @Override
-      final Reference<Option<A>> newReference(final Option<A> o) { return new WeakReference<>(o); }
-      @Override public final P1<A> weakMemo() { return this; }
+      <B> Reference<B> newReference(final B ref) { return new WeakReference<>(ref); }
+      @Override public P1<A> weakMemo() { return this; }
     }
 
-    static class SoftReferenceMemo<A> extends ReferenceMemo<A> {
+    static final class SoftReferenceMemo<A> extends ReferenceMemo<A> {
       SoftReferenceMemo(P1<A> self) { super(self); }
       @Override
-      final Reference<Option<A>> newReference(final Option<A> o) { return new SoftReference<>(o); }
-      @Override public final P1<A> softMemo() { return this; }
+      <B> Reference<B> newReference(final B ref) { return new SoftReference<>(ref); }
+      @Override public P1<A> softMemo() { return this; }
+      @Override public P1<A> weakMemo() { return this; }
     }
 
     /**

From 9394d84652156be1d1ffe359f0a7b37523fab452 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 25 Sep 2016 18:49:32 +0200
Subject: [PATCH 148/336] Use weakMemo() explicitly.

---
 core/src/main/java/fj/P1.java                    | 4 ++--
 core/src/test/java/fj/P1Test.java                | 2 +-
 props-core/src/test/java/fj/MemoisationTest.java | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index cf763f55..2f3fa721 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -262,11 +262,11 @@ public final P1<A> memo() {
     public P1<A> softMemo() { return new SoftReferenceMemo<>(this); }
 
     public static <A> P1<A> memo(F<Unit, A> f) {
-        return P.lazy(f).memo();
+        return P.lazy(f).weakMemo();
     }
 
 	public static <A> P1<A> memo(F0<A> f) {
-		return P.lazy(f).memo();
+		return P.lazy(f).weakMemo();
 	}
 
     static final class Memo<A> extends P1<A> {
diff --git a/core/src/test/java/fj/P1Test.java b/core/src/test/java/fj/P1Test.java
index a866e0c2..788c2829 100644
--- a/core/src/test/java/fj/P1Test.java
+++ b/core/src/test/java/fj/P1Test.java
@@ -11,7 +11,7 @@ public final class P1Test {
 
   @Test
   public void bug105() throws Exception {
-    final P1<String> p1 = P.p("Foo").memo();
+    final P1<String> p1 = P.p("Foo").weakMemo();
     final AtomicInteger nullCounter = new AtomicInteger();
     ExecutorService executorService = Executors.newCachedThreadPool();
 
diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
index ac686465..e86e2a8b 100644
--- a/props-core/src/test/java/fj/MemoisationTest.java
+++ b/props-core/src/test/java/fj/MemoisationTest.java
@@ -19,7 +19,7 @@ public class MemoisationTest {
 
     public Property test1() {
         return property(arbInteger, a -> {
-            P1<Integer> t = P.lazy(() -> a).memo();
+            P1<Integer> t = P.lazy(() -> a).weakMemo();
             return prop(t._1().equals(t._1())).and(prop(t._1().equals(a)));
         });
     }

From e723d7122c00feec41d3375f327a819f7804f454 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 25 Sep 2016 19:09:01 +0200
Subject: [PATCH 149/336] Fix wrong override in P.p(A)

---
 core/src/main/java/fj/P.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index 1ff82475..ebc2d9e4 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -32,7 +32,7 @@ public static <A> P1<A> p(final A a) {
       @Override public A _1() {
         return a;
       }
-      @Override public P1<A> memo() { return this; }
+      @Override public P1<A> hardMemo() { return this; }
       @Override public P1<A> weakMemo() { return this; }
       @Override public P1<A> softMemo() { return this; }
     };

From f56fa238e3dd6022f8558ab5f35835123953d331 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 11:32:27 +0200
Subject: [PATCH 150/336] P1.*memo: avoid uncessary wrapping of F0 value into a
 P1.lazy when possible. Expose static factories in P for this. Deprecated
 redondant API.

---
 core/src/main/java/fj/P.java                  | 50 ++++++++++++++-----
 core/src/main/java/fj/P1.java                 | 43 ++++++++++------
 core/src/main/java/fj/P2.java                 |  5 +-
 core/src/main/java/fj/P3.java                 |  8 +--
 core/src/main/java/fj/P4.java                 | 10 ++--
 core/src/main/java/fj/P5.java                 | 12 +++--
 core/src/main/java/fj/P6.java                 | 14 +++---
 core/src/main/java/fj/P7.java                 | 16 +++---
 core/src/main/java/fj/P8.java                 | 18 ++++---
 core/src/main/java/fj/data/Stream.java        |  3 +-
 core/src/test/java/fj/P1Test.java             |  2 +-
 .../src/test/java/fj/MemoisationTest.java     |  4 +-
 12 files changed, 119 insertions(+), 66 deletions(-)

diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index ebc2d9e4..b0f3a31d 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -38,10 +38,45 @@ public static <A> P1<A> p(final A a) {
     };
   }
 
+  /**
+   * Convert a F0 into a P1, using call-by-need semantic:
+   * function f is evaluated at most once, at first to {@link P1#_1()}.
+   */
+  public static <A> P1<A> hardMemo(F0<A> f) {
+    return new P1.Memo<>(f);
+  }
 
-    public static <A> P1<A> lazy(final P1<A> pa) {
-        return pa;
-    }
+  /**
+   * Convert a F0 into a P1, using weak call-by-need semantic:
+   * function f is evaluated at first call to {@link P1#_1()}
+   * and at each subsequent call if and only if the reference have been garbage collected.
+   */
+  public static <A> P1<A> weakMemo(F0<A> f) {
+    return new P1.WeakReferenceMemo<>(f);
+  }
+
+  /**
+   * Convert a F0 into a P1, using soft call-by-need semantic:
+   * function f is evaluated at first call to {@link P1#_1()}
+   * and at each subsequent call if and only if the reference have been garbage collected
+   * due of shortage of memory (ie. to avoid OutOfMemoryErrors).
+   */
+  public static <A> P1<A> sofMemo(F0<A> f) {
+    return new P1.SoftReferenceMemo<>(f);
+  }
+
+  /**
+   * Convert a F0 into a P1, using call-by-name semantic:
+   * function f is evaluated at each call to {@link P1#_1()}.
+   */
+  public static <A> P1<A> lazy(F0<A> f) {
+    return new P1<A>() {
+      @Override
+      public A _1() {
+        return f.f();
+      }
+    };
+  }
 
     public static <A, B> P2<A, B> lazy(final F0<A> pa, final F0<B> pb) {
         return new P2<A, B>() {
@@ -538,15 +573,6 @@ public H _8() {
     };
   }
 
-    public static <A> P1<A> lazy(F0<A> f) {
-        return new P1<A>() {
-            @Override
-            public A _1() {
-                return f.f();
-            }
-        };
-    }
-
     public static <A> P1<A> lazy(F<Unit, A> f) {
         return lazy(() -> f.f(unit()));
     }
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 2f3fa721..555a28ae 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -12,6 +12,7 @@
 import java.lang.ref.WeakReference;
 
 import static fj.P.p;
+import static fj.Unit.unit;
 //import fj.data.*;
 
 
@@ -240,6 +241,10 @@ public final <B> P1<B> map(final F<A, B> f) {
         return P.lazy(() -> f.f(self._1()));
       }
 
+    /**
+     * @deprecated since 4.7. Use {@link P1#weakMemo()} instead.
+     */
+    @Deprecated
     public final P1<A> memo() {
         return weakMemo();
     }
@@ -261,29 +266,37 @@ public final P1<A> memo() {
      */
     public P1<A> softMemo() { return new SoftReferenceMemo<>(this); }
 
+    /**
+     * @deprecated since 4.7. Use {@link P#weakMemo(F0)} instead.
+     */
+    @Deprecated
     public static <A> P1<A> memo(F<Unit, A> f) {
-        return P.lazy(f).weakMemo();
+        return P.weakMemo(() -> f.f(unit()));
     }
 
-	public static <A> P1<A> memo(F0<A> f) {
-		return P.lazy(f).weakMemo();
+  /**
+   * @deprecated since 4.7. Use {@link P#weakMemo(F0)} instead.
+   */
+  @Deprecated
+  public static <A> P1<A> memo(F0<A> f) {
+		return P.weakMemo(f);
 	}
 
     static final class Memo<A> extends P1<A> {
-      private volatile P1<A> self;
+      private volatile F0<A> fa;
       private A value;
 
-      Memo(P1<A> self) { this.self = self; }
+      Memo(F0<A> fa) { this.fa = fa; }
 
       @Override public final A _1() {
-        return (self == null) ? value : computeValue();
+        return (fa == null) ? value : computeValue();
       }
 
       private synchronized A computeValue() {
-        P1<A> self = this.self;
-        if (self != null) {
-          value = self._1();
-          this.self = null;
+        F0<A> fa = this.fa;
+        if (fa != null) {
+          value = fa.f();
+          this.fa = null;
         }
         return value;
       }
@@ -294,10 +307,10 @@ private synchronized A computeValue() {
     }
 
     abstract static class ReferenceMemo<A> extends P1<A> {
-      private final P1<A> self;
+      private final F0<A> fa;
       private volatile Reference<P1<A>> v = null;
 
-      ReferenceMemo(final P1<A> self) { this.self = self; }
+      ReferenceMemo(final F0<A> fa) { this.fa = fa; }
 
       @Override public final A _1() {
         Reference<P1<A>> v = this.v;
@@ -309,7 +322,7 @@ private synchronized A computeValue() {
         Reference<P1<A>> v = this.v;
         P1<A> p1 = v != null ? v.get() : null;
         if (p1 == null) {
-          A a = self._1();
+          A a = fa.f();
           this.v = newReference(p(a));
           return a;
         }
@@ -320,14 +333,14 @@ private synchronized A computeValue() {
     }
 
     static final class WeakReferenceMemo<A> extends ReferenceMemo<A> {
-      WeakReferenceMemo(P1<A> self) { super(self); }
+      WeakReferenceMemo(F0<A> fa) { super(fa); }
       @Override
       <B> Reference<B> newReference(final B ref) { return new WeakReference<>(ref); }
       @Override public P1<A> weakMemo() { return this; }
     }
 
     static final class SoftReferenceMemo<A> extends ReferenceMemo<A> {
-      SoftReferenceMemo(P1<A> self) { super(self); }
+      SoftReferenceMemo(F0<A> self) { super(self); }
       @Override
       <B> Reference<B> newReference(final B ref) { return new SoftReference<>(ref); }
       @Override public P1<A> softMemo() { return this; }
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index abe4d0d5..e503ff40 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -1,6 +1,7 @@
 package fj;
 
 import static fj.Function.*;
+import static fj.P.weakMemo;
 import static fj.data.optic.PLens.pLens;
 import fj.data.*;
 import fj.data.optic.Lens;
@@ -185,8 +186,8 @@ public final P1<B> _2_() {
     public final P2<A, B> memo() {
         P2<A, B> self = this;
         return new P2<A, B>() {
-            private final P1<A> a = P1.memo(u -> self._1());
-            private final P1<B> b = P1.memo(u -> self._2());
+            private final P1<A> a = weakMemo(self::_1);
+            private final P1<B> b = weakMemo(self::_2);
 
             public A _1() {
                 return a._1();
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index 26c51b05..ec277346 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-3.
  *
@@ -128,9 +130,9 @@ public final P1<C> _3_() {
   public final P3<A, B, C> memo() {
       P3<A, B, C> self = this;
     return new P3<A, B, C>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index c2f94f8f..3f7236fe 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-4.
  *
@@ -182,10 +184,10 @@ public final P1<D> _4_() {
   public final P4<A, B, C, D> memo() {
       P4<A, B, C, D> self = this;
     return new P4<A, B, C, D>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
-      private final P1<D> d = P1.memo(u -> self._4());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
+      private final P1<D> d = weakMemo(self::_4);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 902da93c..393b0632 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-5.
  *
@@ -244,11 +246,11 @@ public final P1<E> _5_() {
   public final P5<A, B, C, D, E> memo() {
       P5<A, B, C, D, E> self = this;
     return new P5<A, B, C, D, E>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
-      private final P1<D> d = P1.memo(u -> self._4());
-      private final P1<E> e = P1.memo(u -> self._5());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
+      private final P1<D> d = weakMemo(self::_4);
+      private final P1<E> e = weakMemo(self::_5);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index 37f5fe6c..1e8c3055 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-6.
  *
@@ -315,12 +317,12 @@ public final P1<F> _6_() {
   public final P6<A, B, C, D, E, F> memo() {
       P6<A, B, C, D, E, F> self = this;
     return new P6<A, B, C, D, E, F>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
-      private final P1<D> d = P1.memo(u -> self._4());
-      private final P1<E> e = P1.memo(u -> self._5());
-      private final P1<F> f = P1.memo(u -> self._6());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
+      private final P1<D> d = weakMemo(self::_4);
+      private final P1<E> e = weakMemo(self::_5);
+      private final P1<F> f = weakMemo(self::_6);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index e2673183..ca24b40e 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-7.
  *
@@ -393,13 +395,13 @@ public final P1<G> _7_() {
   public final P7<A, B, C, D, E, F, G> memo() {
       P7<A, B, C, D, E, F, G> self = this;
     return new P7<A, B, C, D, E, F, G>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
-      private final P1<D> d = P1.memo(u -> self._4());
-      private final P1<E> e = P1.memo(u -> self._5());
-      private final P1<F> f = P1.memo(u -> self._6());
-      private final P1<G> g = P1.memo(u -> self._7());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
+      private final P1<D> d = weakMemo(self::_4);
+      private final P1<E> e = weakMemo(self::_5);
+      private final P1<F> f = weakMemo(self::_6);
+      private final P1<G> g = weakMemo(self::_7);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index cfa916eb..f15d63a1 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -1,5 +1,7 @@
 package fj;
 
+import static fj.P.weakMemo;
+
 /**
  * A product-8.
  *
@@ -480,14 +482,14 @@ public final P1<H> _8_() {
   public final P8<A, B, C, D, E, F, G, H> memo() {
       P8<A, B, C, D, E, F, G, H> self = this;
     return new P8<A, B, C, D, E, F, G, H>() {
-      private final P1<A> a = P1.memo(u -> self._1());
-      private final P1<B> b = P1.memo(u -> self._2());
-      private final P1<C> c = P1.memo(u -> self._3());
-      private final P1<D> d = P1.memo(u -> self._4());
-      private final P1<E> e = P1.memo(u -> self._5());
-      private final P1<F> f = P1.memo(u -> self._6());
-      private final P1<G> g = P1.memo(u -> self._7());
-      private final P1<H> h = P1.memo(u -> self._8());
+      private final P1<A> a = weakMemo(self::_1);
+      private final P1<B> b = weakMemo(self::_2);
+      private final P1<C> c = weakMemo(self::_3);
+      private final P1<D> d = weakMemo(self::_4);
+      private final P1<E> e = weakMemo(self::_5);
+      private final P1<F> f = weakMemo(self::_6);
+      private final P1<G> g = weakMemo(self::_7);
+      private final P1<H> h = weakMemo(self::_8);
 
       public A _1() {
         return a._1();
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index ae37d714..e4baccf5 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -25,6 +25,7 @@
 import static fj.Function.*;
 import static fj.P.p;
 import static fj.P.p2;
+import static fj.P.weakMemo;
 import static fj.Unit.unit;
 import static fj.control.parallel.Promise.promise;
 import static fj.data.Array.mkArray;
@@ -1442,7 +1443,7 @@ private static final class Cons<A> extends Stream<A> {
 
     Cons(final A head, final F0<Stream<A>> tail) {
       this.head = head;
-      this.tail = P1.memo(tail);
+      this.tail = weakMemo(tail);
     }
 
     public A head() {
diff --git a/core/src/test/java/fj/P1Test.java b/core/src/test/java/fj/P1Test.java
index 788c2829..4d3c5c35 100644
--- a/core/src/test/java/fj/P1Test.java
+++ b/core/src/test/java/fj/P1Test.java
@@ -11,7 +11,7 @@ public final class P1Test {
 
   @Test
   public void bug105() throws Exception {
-    final P1<String> p1 = P.p("Foo").weakMemo();
+    final P1<String> p1 = P.weakMemo(() -> "Foo");
     final AtomicInteger nullCounter = new AtomicInteger();
     ExecutorService executorService = Executors.newCachedThreadPool();
 
diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
index e86e2a8b..65fa83fc 100644
--- a/props-core/src/test/java/fj/MemoisationTest.java
+++ b/props-core/src/test/java/fj/MemoisationTest.java
@@ -19,14 +19,14 @@ public class MemoisationTest {
 
     public Property test1() {
         return property(arbInteger, a -> {
-            P1<Integer> t = P.lazy(() -> a).weakMemo();
+            P1<Integer> t = P.weakMemo(() -> a);
             return prop(t._1().equals(t._1())).and(prop(t._1().equals(a)));
         });
     }
 
     public Property test1_hardMemo() {
         return property(arbInteger, a -> {
-            P1<Integer> t = P.lazy(() -> new Integer(a)).hardMemo();
+            P1<Integer> t = P.hardMemo(() -> new Integer(a));
             return prop(t._1() == t._1()).and(prop(t._1().equals(a)));
         });
     }

From 0e3187feb37751669028ceb6f06e6b012d47fa8b Mon Sep 17 00:00:00 2001
From: JB Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 11:46:20 +0100
Subject: [PATCH 151/336] Add a Hash Array Mapped Trie

* Copied hamt from personal repo

* Created show instances.  Fixed BitSet.xor

* Fixing overflow on BitSet longs.  Adding tests

* BitSet properties test

* More BitSetProperties tests

* Added remaining BitSet properties required

* Moved hamt to String to the Show class

* Clean up hamt test print lines

* Updated after Gen/Arbitrary changes

* Changed BitSet method name for creation from a long value

* Fixed BitSet.asString

* Added javadoc for HAMT

* Added javadoc for HAMT

* More tests on BitSet

* Added more tests and minor refactoring for BitSet

* Fixed BitSet.takeUpper

* Fixed HAMT issue

* Deleted BitSetTest

* Fixed find and set.  Added folds for HAMT

* Properties and ad hoc tests for HAMT properties

* Added Seq insert and filter

* Added count population (CTPOP) from the paper for a bit set

* Minor clean-up, remove dead-code.

* improve BitSet#range performance (use bitwise operations)

* remove unnecessary lambda
---
 core/src/main/java/fj/Equal.java              |   3 +
 core/src/main/java/fj/Show.java               |  22 +-
 core/src/main/java/fj/data/Seq.java           |  17 ++
 core/src/main/java/fj/data/hamt/BitSet.java   | 204 ++++++++++++++++
 .../fj/data/hamt/HashArrayMappedTrie.java     | 220 ++++++++++++++++++
 core/src/main/java/fj/data/hamt/Node.java     |  56 +++++
 core/src/test/java/fj/data/SeqTest.java       |   9 +
 core/src/test/java/fj/data/hamt/HamtTest.java |  66 ++++++
 .../java/fj/data/hamt/BitSetProperties.java   | 218 +++++++++++++++++
 .../hamt/HashArrayMappedTrieProperties.java   |  94 ++++++++
 quickcheck/src/main/java/fj/test/Gen.java     |  10 +
 quickcheck/src/main/java/fj/test/Rand.java    |   3 +
 .../src/test/java/fj/test/TestRand.java       |   2 +-
 13 files changed, 921 insertions(+), 3 deletions(-)
 create mode 100644 core/src/main/java/fj/data/hamt/BitSet.java
 create mode 100644 core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
 create mode 100644 core/src/main/java/fj/data/hamt/Node.java
 create mode 100644 core/src/test/java/fj/data/hamt/HamtTest.java
 create mode 100644 props-core/src/test/java/fj/data/hamt/BitSetProperties.java
 create mode 100644 props-core/src/test/java/fj/data/hamt/HashArrayMappedTrieProperties.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index a09dceba..b3709f4b 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -3,6 +3,7 @@
 import static fj.Function.curry;
 
 import fj.data.*;
+import fj.data.hamt.BitSet;
 import fj.data.hlist.HList;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
@@ -104,6 +105,8 @@ public static <A> Equal<A> anyEqual() {
    */
   public static final Equal<Boolean> booleanEqual = anyEqual();
 
+  public static final Equal<BitSet> bitSetSequal = Equal.equal(bs1 -> bs2 -> bs1.longValue() == bs2.longValue());
+
   /**
    * An equal instance for the <code>byte</code> type.
    */
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 9e55a1d6..2d2c4707 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -1,8 +1,9 @@
 package fj;
 
 import fj.data.*;
+import fj.data.hamt.BitSet;
+import fj.data.hamt.HashArrayMappedTrie;
 import fj.data.fingertrees.FingerTree;
-import fj.data.fingertrees.Node;
 import fj.data.hlist.HList;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
@@ -315,7 +316,7 @@ public static <V, A> Show<fj.data.fingertrees.Digit<V, A>> digitShow(final Show<
     });
   }
 
-  public static <V, A> Show<Node<V, A>> nodeShow(final Show<V> sv, final Show<A> sa) {
+  public static <V, A> Show<fj.data.fingertrees.Node<V, A>> nodeShow(final Show<V> sv, final Show<A> sa) {
     return show(n -> {
       final String s = n.match(
           n2 -> "Node2(" + n2.measure() + " -> " + v2Show(sa).showS(n2.toVector()) + ")",
@@ -701,4 +702,21 @@ public static <A> Show<Stream<A>> unlineShow(final Show<A> sa) {
   public static <E, L extends HList<L>> Show<HList.HCons<E, L>> HListShow(final Show<E> e, final Show<L> l) {
     return show(c -> fromString("HList(").append(e.show(c.head())).append(l.show(c.tail())).append(fromString(")")));
   }
+
+  public static <K, V> Show<fj.data.hamt.Node<K, V>> hamtNodeShow(Show<K> sk, Show<V> sv) {
+    F<fj.data.hamt.Node<K, V>, String> f = n -> n.match(p -> p2Show(sk, sv).showS(p), h -> hamtShow(sk, sv).showS(h));
+    return Show.showS(f);
+  }
+
+  public static <K, V> Show<HashArrayMappedTrie<K, V>> hamtShow(Show<K> sk, Show<V> sv) {
+    return Show.showS(hamt ->
+      "HashArrayMappedTrie(" + Show.bitSetShow.showS(hamt.getBitSet()) +
+      ", " + Show.seqShow(Show.hamtNodeShow(sk, sv)).showS(hamt.getSeq()) + ")"
+    );
+  }
+
+  public static final Show<BitSet> bitSetShow = Show.showS(
+          bs -> "BitSet(" + bs.asString() + ")"
+  );
+
 }
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index c6eb98be..abd20162 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -275,6 +275,18 @@ public boolean isEmpty() {
     return ftree.isEmpty();
   }
 
+  /**
+   * Inserts the element at the given index. This is an O(log(n)) operation.
+   *
+   * @param index The index of the element to return.
+   * @return The sequence with the element inserted at the given index,
+   * or throws an error if the index is out of bounds.
+   */
+  public Seq<A> insert(int index, A a) {
+    final P2<Seq<A>, Seq<A>> p = split(index);
+    return p._1().append(single(a)).append(p._2());
+  }
+
   /**
    * Checks if this sequence is not empty.
    *
@@ -370,6 +382,11 @@ public <B> B foldRight(final F2<A, B, B> f, final B z) {
         return ftree.foldRight(f, z);
     }
 
+
+  public Seq<A> filter(F<A, Boolean> f) {
+    return foldLeft((acc, a) -> f.f(a) ? acc.snoc(a) : acc, empty());
+  }
+
     @Override
     public int hashCode() {
       return Hash.seqHash(Hash.<A>anyHash()).hash(this);
diff --git a/core/src/main/java/fj/data/hamt/BitSet.java b/core/src/main/java/fj/data/hamt/BitSet.java
new file mode 100644
index 00000000..d164642d
--- /dev/null
+++ b/core/src/main/java/fj/data/hamt/BitSet.java
@@ -0,0 +1,204 @@
+package fj.data.hamt;
+
+import fj.Equal;
+import fj.F2;
+import fj.Monoid;
+import fj.Show;
+import fj.data.List;
+import fj.data.Stream;
+
+/**
+ * A sequence of bits representing a value.  The most significant bit (the
+ * bit with the highest value) is the leftmost bit and has the highest index.
+ * For example, the BitSet("1011") represents the decimal number 11 and has
+ * indices [3, 0] inclusive where the bit with the lowest value has the lowest
+ * index and is the rightmost bit.
+ *
+ * Created by maperr on 31/05/2016.
+ */
+public final class BitSet {
+
+    public static final int TRUE_BIT = 1;
+    public static final int FALSE_BIT = 0;
+    public static final BitSet EMPTY = new BitSet(FALSE_BIT);
+
+    public static final long BASE_LONG = 1L;
+    public static final int MAX_BIT_SIZE = Long.SIZE;
+    public static final int MAX_BIT_INDEX = Long.SIZE - 1;
+
+    private final long value;
+
+    private BitSet(final long l) {
+        value = l;
+    }
+
+    public static BitSet empty() {
+        return EMPTY;
+    }
+
+    public static BitSet longBitSet(final long l) {
+        return new BitSet(l);
+    }
+
+    public static BitSet listBitSet(final List<Boolean> list) {
+        final int n = list.length();
+        if (n > MAX_BIT_SIZE) {
+            throw new IllegalArgumentException("Does not support lists greater than " + MAX_BIT_SIZE + " bits, actual size is " + n);
+        }
+        long result = 0;
+        for (Boolean b: list) {
+            result = (result << 1) | toInt(b);
+        }
+        return longBitSet(result);
+    }
+
+    public static BitSet streamBitSet(final Stream<Boolean> s) {
+        return listBitSet(s.toList());
+    }
+
+    public static BitSet stringBitSet(final String s) {
+        return streamBitSet(Stream.fromString(s).map(BitSet::toBoolean));
+    }
+
+    public boolean isSet(final int index) {
+        return (value & (BASE_LONG << index)) != 0;
+    }
+
+    public boolean isEmpty() {
+        return value == 0;
+    }
+
+    public BitSet set(final int index) {
+        return longBitSet(value | (BASE_LONG << index));
+    }
+
+    public BitSet set(final int index, boolean b) {
+        return b ? set(index) : clear(index);
+    }
+
+    public BitSet clear(final int index) {
+        return longBitSet(value & ~(BASE_LONG << index));
+    }
+
+    public long longValue() {
+        return value;
+    }
+
+    public BitSet and(final BitSet bs) {
+        return longBitSet(value & bs.longValue());
+    }
+
+    public BitSet or(final BitSet bs) {
+        return longBitSet(value | bs.longValue());
+    }
+
+    public BitSet shiftRight(final int n) {
+        return longBitSet(value >> n);
+    }
+
+    public BitSet shiftLeft(final int n) {
+        return longBitSet(value << n);
+    }
+
+    public int bitsUsed() {
+        return toStream().length();
+    }
+
+    public int bitsOn() {
+        return toStream().foldLeft((acc, b) -> acc + (b ? 1 : 0), 0);
+    }
+
+    /**
+     * Returns a stream of boolean where the head is the most significant bit
+     * (the bit with the largest value)
+     */
+    public Stream<Boolean> toStream() {
+        return Stream.fromString(Long.toBinaryString(value)).map(BitSet::toBoolean).dropWhile(b -> !b);
+    }
+
+    @Override
+    public String toString() {
+        return Show.bitSetShow.showS(this);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return Equal.equals0(BitSet.class, this, obj, Equal.bitSetSequal);
+    }
+
+    public int bitsToRight(final int index) {
+        if (index >= MAX_BIT_SIZE) {
+            throw new IllegalArgumentException("Does not support an index " +
+                    "greater than or equal to " + MAX_BIT_SIZE + " bits, actual argument is " + index);
+        }
+        int pos = index - 1;
+        long mask = BASE_LONG << (pos);
+        int result = 0;
+        while (pos >= 0) {
+            if ((mask & value) != 0) {
+                result++;
+            }
+            mask = mask >> 1;
+            pos--;
+        }
+        return result;
+    }
+
+    public List<Boolean> toList() {
+        return toStream().toList();
+    }
+
+    public <A> A foldRight(final F2<Boolean, A, A> f, A acc) {
+        return toStream().foldRight(b -> p -> f.f(b, p._1()), acc);
+    }
+
+    public <A> A foldLeft(final F2<A, Boolean, A> f, A acc) {
+        return toStream().foldLeft(f, acc);
+    }
+
+    public BitSet xor(final BitSet bs) {
+        return longBitSet(value ^ bs.longValue());
+    }
+
+    public BitSet not() {
+        return longBitSet(~value);
+    }
+
+    public BitSet takeLower(final int n) {
+        return streamBitSet(toStream().reverse().take(n).reverse());
+    }
+
+    public BitSet takeUpper(final int n) {
+        String zero = Integer.toString(FALSE_BIT);
+        String current = asString();
+        String pad = Monoid.stringMonoid.sumLeft(List.replicate(MAX_BIT_SIZE - current.length(), zero));
+        return stringBitSet(pad + current.substring(0, Math.max(n - pad.length(), 0)));
+    }
+
+    /**
+     * Returns the bit set from indices in the range from low (inclusive)
+     * to high(exclusive) from the least significant bit (on the right),
+     * e.g. "101101".range(1, 4) == "0110"
+     */
+    public BitSet range(final int highIndex, final int lowIndex) {
+        int max = Math.max(lowIndex, highIndex);
+        int min = Math.min(lowIndex, highIndex);
+        return new BitSet(max == min ? 0L : (value << (64 - max)) >>> (64 - max + min));
+    }
+
+    public static boolean toBoolean(final char c) {
+        return c != '0';
+    }
+
+    public static boolean toBoolean(final int i) {
+        return i != FALSE_BIT;
+    }
+
+    public static int toInt(final boolean b) {
+        return b ? TRUE_BIT : FALSE_BIT;
+    }
+
+    public String asString() {
+        return Long.toBinaryString(value);
+    }
+}
diff --git a/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java b/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
new file mode 100644
index 00000000..f13ae90f
--- /dev/null
+++ b/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
@@ -0,0 +1,220 @@
+package fj.data.hamt;
+
+import fj.Equal;
+import fj.F2;
+import fj.Hash;
+import fj.Ord;
+import fj.P2;
+import fj.Show;
+import fj.data.List;
+import fj.data.Option;
+import fj.data.Seq;
+import fj.data.Stream;
+
+import static fj.P.p;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+import static fj.data.hamt.BitSet.longBitSet;
+
+/**
+ * A hash array mapped trie (HAMT) is an implementation of an associative
+ * array that combines the characteristics of a hash table and an array
+ * mapped trie.  It is a refined version of the more general notion of
+ * a hash tree.
+ *
+ * @author Mark Perry
+ *
+ * Based on "Ideal Hash Trees" by Phil Bagwell, available from
+ * http://lampwww.epfl.ch/papers/idealhashtrees.pdf
+ */
+public final class HashArrayMappedTrie<K, V> {
+
+    private final Seq<Node<K, V>> seq;
+    private final BitSet bitSet;
+    private final Hash<K> hash;
+    private final Equal<K> equal;
+
+    public static final int BITS_IN_INDEX = 5;
+    public static final int SIZE = (int) StrictMath.pow(2, BITS_IN_INDEX);
+    public static final int MIN_INDEX = 0;
+    public static final int MAX_INDEX = SIZE - 1;
+
+    /**
+     * Creates an empty trie for the bitset, sequence of nodes, equal and hash.
+     *
+     * @param bs - The set of bits to indicate which of the SIZE nodes in the sequence are used.
+     * @param s - The sequence of HAMT nodes - either a HAMT or a key-value pair.
+     * @param e - Equality instance for keys.
+     * @param h - Hash instance for keys.
+     */
+    private HashArrayMappedTrie(final BitSet bs, final Seq<Node<K, V>> s, final Equal<K> e, final Hash<K> h) {
+        bitSet = bs;
+        seq = s;
+        hash = h;
+        equal = e;
+    }
+
+    /**
+     * Creates an empty trie.
+     */
+    public static <K, V> HashArrayMappedTrie<K, V> empty(final Equal<K> e, final Hash<K> h) {
+        return new HashArrayMappedTrie<>(BitSet.empty(), Seq.empty(), e, h);
+    }
+
+    /**
+     * Create and empty trie keyed by integer.
+     */
+    public static <V> HashArrayMappedTrie<Integer, V> emptyKeyInteger() {
+        return empty(Equal.intEqual, Hash.intHash);
+    }
+
+    /**
+     * Returns if the trie is empty.
+     */
+    public boolean isEmpty() {
+        return bitSet.isEmpty();
+    }
+
+    /**
+     * Static constructor for a HAMT instance.
+     */
+    private static <K, V> HashArrayMappedTrie<K, V> hamt(final BitSet bs, final Seq<Node<K, V>> s, final Equal<K> e, final Hash<K> h) {
+        return new HashArrayMappedTrie<>(bs, s, e, h);
+    }
+
+    /**
+     * Returns an optional value for the given key k.
+     */
+    public Option<V> find(final K k) {
+        return find(k, MIN_INDEX, MIN_INDEX + BITS_IN_INDEX);
+    }
+
+    /**
+     * Returns an optional value for the given key k for those nodes between
+     * lowIndex (inclusive) and highIndex (exclusive).
+     */
+    public Option<V> find(final K k, final int lowIndex, final int highIndex) {
+        BitSet bs1 = longBitSet(hash.hash(k)).range(lowIndex, highIndex);
+        int i = (int) bs1.longValue();
+        boolean b = bitSet.isSet(i);
+        final int index = bitSet.bitsToRight(i);
+        if (!b) {
+            return none();
+        } else {
+            final Node<K, V> oldNode = seq.index(index);
+            return oldNode.match(
+                n -> equal.eq(n._1(), k) ? some(n._2()) : none(),
+                hamt -> hamt.find(k, lowIndex + BITS_IN_INDEX, highIndex + BITS_IN_INDEX)
+            );
+        }
+    }
+
+    /**
+     * Adds the key-value pair (k, v) to the trie.
+     */
+    public HashArrayMappedTrie<K, V> set(final K k, final V v) {
+        return set(k, v, MIN_INDEX, MIN_INDEX + BITS_IN_INDEX);
+    }
+
+    /**
+     * Adds the product of key-value (k, v) pairs to the trie.
+     */
+    public HashArrayMappedTrie<K, V> set(final List<P2<K, V>> list) {
+        return list.foldLeft(h -> p -> h.set(p._1(), p._2()), this);
+    }
+
+    /**
+     * Sets the key-value pair (k, v) for the bit range lowIndex (inclusive) to highIndex (exclusive).
+     */
+    private HashArrayMappedTrie<K, V> set(final K k, final V v, final int lowIndex, final int highIndex) {
+        final BitSet bs1 = longBitSet(hash.hash(k)).range(lowIndex, highIndex);
+        final int i = (int) bs1.longValue();
+        final boolean b = bitSet.isSet(i);
+        final int index = bitSet.bitsToRight(i);
+
+        if (!b) {
+            // append new node
+            final Node<K, V> sn1 = Node.p2Node(p(k, v));
+            return hamt(bitSet.set(i), seq.insert(index, sn1), equal, hash);
+        } else {
+            final Node<K, V> oldNode = seq.index(index);
+            final Node<K, V> newNode = oldNode.match(n -> {
+                if (equal.eq(n._1(), k)) {
+                    return Node.p2Node(p(k, v));
+                } else {
+                    final HashArrayMappedTrie<K, V> e = HashArrayMappedTrie.empty(equal, hash);
+                    final HashArrayMappedTrie<K, V> h1 =  e.set(n._1(), n._2(), lowIndex + BITS_IN_INDEX, highIndex + BITS_IN_INDEX);
+                    final HashArrayMappedTrie<K, V> h2 = h1.set(k, v, lowIndex + BITS_IN_INDEX, highIndex + BITS_IN_INDEX);
+                    return Node.hamtNode(h2);
+                }
+            }, hamt -> Node.hamtNode(hamt.set(k, v, lowIndex + BITS_IN_INDEX, highIndex + BITS_IN_INDEX))
+            );
+            return hamt(bitSet, seq.update(index, newNode), equal, hash);
+        }
+    }
+
+    /**
+     * Returns a stream of key-value pairs.
+     */
+    public Stream<P2<K, V>> toStream() {
+        return seq.toStream().bind(Node::toStream);
+    }
+
+    /**
+     * Returns the list of key-value pairs, ordered by key.
+     */
+    public List<P2<K, V>> toList(Ord<K> o) {
+        return toStream().sort(Ord.p2Ord1(o)).toList();
+    }
+
+    /**
+     * Returns a list of key-value pairs.
+     */
+    public List<P2<K, V>> toList() {
+        return toStream().toList();
+    }
+
+    @Override
+    public String toString() {
+        return Show.hamtShow(Show.<K>anyShow(), Show.<V>anyShow()).showS(this);
+    }
+
+    /**
+     * Performs a left-fold reduction across this trie.
+     */
+    public <B> B foldLeftOnNode(F2<B, Node<K, V>, B> f, B b) {
+        return seq.foldLeft(f, b);
+    }
+
+    /**
+     * Performs a left-fold reduction across this trie.
+     */
+    public <B> B foldLeft(F2<B, P2<K, V>, B> f, F2<B, HashArrayMappedTrie<K, V>, B> g, B b) {
+        return foldLeftOnNode((acc, n) -> n.match(p -> f.f(acc, p), h -> g.f(acc, h)), b);
+    }
+
+    /**
+     * Performs a left-fold reduction across this trie.
+     */
+    public <B> B foldLeft(F2<B, P2<K, V>, B> f, B b) {
+        return foldLeftOnNode((acc, n) -> n.match(p -> f.f(acc, p), h -> h.foldLeft(f, acc)), b);
+    }
+
+    public BitSet getBitSet() {
+        return bitSet;
+    }
+
+    public Seq<Node<K, V>> getSeq() {
+        return seq;
+    }
+
+    /**
+     * Returns the number of elements in the trie.
+     */
+    public int length() {
+        return seq.foldLeft(
+            (acc, node) -> node.match(p2 -> acc + 1, hamt -> acc + hamt.length()), 0
+        );
+    }
+
+}
diff --git a/core/src/main/java/fj/data/hamt/Node.java b/core/src/main/java/fj/data/hamt/Node.java
new file mode 100644
index 00000000..f8a1ff40
--- /dev/null
+++ b/core/src/main/java/fj/data/hamt/Node.java
@@ -0,0 +1,56 @@
+package fj.data.hamt;
+
+import fj.F;
+import fj.P2;
+import fj.Show;
+import fj.data.Either;
+import fj.data.Option;
+import fj.data.Stream;
+
+/**
+ * A Hash Array Mapped Trie node that is either a key-value pair or a
+ * Hash Array Mapped Trie.
+ *
+ * Created by maperr on 31/05/2016.
+ */
+public final class Node<K, V> {
+
+    private final Either<P2<K, V>, HashArrayMappedTrie<K, V>> either;
+
+    public Node(final Either<P2<K, V>, HashArrayMappedTrie<K, V>> e) {
+        either = e;
+    }
+
+    public Node(final P2<K, V> simpleNode) {
+        this(Either.left(simpleNode));
+    }
+
+    public Node(final HashArrayMappedTrie<K, V> hamt) {
+        this(Either.right(hamt));
+    }
+
+    public static <K, V> Node<K, V> p2Node(final P2<K, V> p) {
+        return new Node<>(p);
+    }
+
+    public static <K, V> Node<K, V> hamtNode(final HashArrayMappedTrie<K, V> hamt) {
+        return new Node<>(hamt);
+    }
+
+    /**
+     * Performs a reduction on this Node using the given arguments.
+     */
+    public <B> B match(final F<P2<K, V>, B> f, final F<HashArrayMappedTrie<K, V>, B> g) {
+        return either.either(f, g);
+    }
+
+    public Stream<P2<K, V>> toStream() {
+        return match(Stream::single, HashArrayMappedTrie::toStream);
+    }
+
+    @Override
+    public String toString() {
+        return Show.hamtNodeShow(Show.<K>anyShow(), Show.<V>anyShow()).showS(this);
+    }
+
+}
diff --git a/core/src/test/java/fj/data/SeqTest.java b/core/src/test/java/fj/data/SeqTest.java
index 633ae321..27ec26e2 100644
--- a/core/src/test/java/fj/data/SeqTest.java
+++ b/core/src/test/java/fj/data/SeqTest.java
@@ -1,5 +1,6 @@
 package fj.data;
 
+import fj.P2;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
@@ -34,4 +35,12 @@ public void convertToString() {
         expected.append(')');
         assertEquals(expected.toString(), Seq.seq(Array.range(0, 10000).array()).toString());
     }
+
+
+    @Test
+    public void test() {
+        P2<Seq<Integer>, Seq<Integer>> p2 = Seq.single(1).split(5);
+        System.out.println(p2);
+    }
+
 }
diff --git a/core/src/test/java/fj/data/hamt/HamtTest.java b/core/src/test/java/fj/data/hamt/HamtTest.java
new file mode 100644
index 00000000..1e601f24
--- /dev/null
+++ b/core/src/test/java/fj/data/hamt/HamtTest.java
@@ -0,0 +1,66 @@
+package fj.data.hamt;
+
+import fj.Ord;
+import fj.P2;
+import fj.data.List;
+import fj.data.Option;
+import org.junit.Test;
+
+import static fj.Equal.intEqual;
+import static fj.Equal.optionEqual;
+import static fj.Hash.intHash;
+import static fj.P.p;
+import static fj.data.List.list;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+/**
+ * @author Mark Perry
+ */
+public class HamtTest {
+
+    public static final HashArrayMappedTrie<Integer, Integer> empty = HashArrayMappedTrie.emptyKeyInteger();
+
+    @Test
+    public void empty() {
+        assertThat(empty.length(), equalTo(0));
+    }
+
+    @Test
+    public void lengthOne() {
+        assertThat(empty.set(3, 6).length(), equalTo(1));
+    }
+
+    @Test
+    public void updateLength() {
+        HashArrayMappedTrie<Integer, Integer> h1 = empty.set(3, 3).set(3, 5);
+        assertThat(h1.length(), equalTo(1));
+    }
+
+    @Test
+    public void streamLength() {
+        List<P2<Integer, Integer>> list = list(p(0, 1), p(31, 1), p(32, 1), p(33, 1));
+        HashArrayMappedTrie<Integer, Integer> h2 = empty.set(list);
+        assertThat(h2.toStream().length(), equalTo(list.length()));
+    }
+
+    @Test
+    public void allIn() {
+        List<P2<Integer, Integer>> list = List.list(p(-5, 0), p(-1, -5), p(2, 4), p(4, -2));
+        HashArrayMappedTrie<Integer, Integer> h = empty.set(list);
+        Boolean b = list.foldLeft((acc, p) -> h.find(p._1()).option(false, i -> true && acc), true);
+        assertThat(b, equalTo(true));
+    }
+
+    @Test
+    public void sampleInts() {
+        List<P2<Integer, Integer>> ps = List.list(p(-3, 0), p(1, 2));
+        int key = -3;
+        HashArrayMappedTrie<Integer, Integer> h = empty.set(ps);
+        Option<Integer> o1 = ps.find(p -> intEqual.eq(p._1(), key)).map(p -> p._2());
+        Option<Integer> o2 = h.find(key);
+        boolean b = optionEqual(intEqual).eq(o1, o2);
+        assertThat(b, equalTo(true));
+    }
+
+}
diff --git a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
new file mode 100644
index 00000000..0ae976ef
--- /dev/null
+++ b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
@@ -0,0 +1,218 @@
+package fj.data.hamt;
+
+import fj.Equal;
+import fj.Ord;
+import fj.P;
+import fj.P3;
+import fj.data.List;
+import fj.data.Seq;
+import fj.data.test.PropertyAssert;
+import fj.function.Booleans;
+import fj.test.Gen;
+import fj.test.Property;
+import fj.test.reflect.CheckParams;
+import fj.test.runner.PropertyTestRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.math.BigInteger;
+
+import static fj.Equal.bitSetSequal;
+import static fj.Equal.booleanEqual;
+import static fj.Equal.listEqual;
+import static fj.Equal.stringEqual;
+import static fj.Function.identity;
+import static fj.data.hamt.BitSet.MAX_BIT_SIZE;
+import static fj.data.hamt.BitSet.listBitSet;
+import static fj.data.hamt.BitSet.longBitSet;
+import static fj.test.Arbitrary.arbBoolean;
+import static fj.test.Arbitrary.arbLong;
+import static fj.test.Property.impliesBoolean;
+import static fj.test.Property.prop;
+import static fj.test.Property.property;
+
+/**
+ * Created by maperr on 31/05/2016.
+ */
+
+@RunWith(PropertyTestRunner.class)
+@CheckParams(maxSize = 10000)
+public class BitSetProperties {
+
+    Property andTest() {
+        return property(arbLong, arbLong, (a, b) -> prop(longBitSet(a).and(longBitSet(b)).longValue() == (a & b)));
+    }
+
+    Property asStringTest() {
+        return property(arbLong, a -> prop(longBitSet(a).asString().equals(Long.toBinaryString(a))));
+    }
+
+    Property bitsToRightTest() {
+        return property(arbLong, arbBitSetSize, (a, i) ->
+            prop(
+                longBitSet(a).bitsToRight(i) ==
+                longBitSet(a).toList().reverse().take(i).filter(identity()).length()
+        ));
+    }
+
+    Property longRoundTripTest() {
+        return property(arbNaturalLong, l -> prop(longBitSet(l).longValue() == l));
+    }
+
+    Property empty() {
+        return prop(BitSet.empty().isEmpty() && BitSet.empty().longValue() == 0);
+    }
+
+    Property generalEmptinessTest() {
+        return property(arbListBoolean, list ->
+                prop(list.dropWhile(Booleans.not).isEmpty() == listBitSet(list).isEmpty())
+        );
+    }
+
+    Property foldLeftTest() {
+        return property(arbLong, l -> prop(
+            BitSet.longBitSet(l).toList().dropWhile(b -> !b).foldLeft(
+                    (acc, b) -> acc + 1, 0
+            ) == BitSet.longBitSet(l).bitsUsed()
+        ));
+    }
+
+    Property fromListTest() {
+        return property(arbListBoolean, l -> prop(listBitSet(l).toList().equals(l.dropWhile(b -> !b))));
+    }
+
+    Property fromStreamTest() {
+        return property(arbListBoolean, l -> prop(listBitSet(l).toStream().toList().equals(l.dropWhile(b -> !b))));
+    }
+
+    Property fromLongTest() {
+        return property(arbLong, l -> prop(BitSet.longBitSet(l).longValue() == l));
+    }
+
+    Property fromStringTest() {
+        Gen<String> g = arbListBoolean.map(l -> l.map(b -> Integer.toString(BitSet.toInt(b))).foldLeft((acc, s) -> acc + s, ""));
+        return property(g, (s) -> {
+            boolean zeroLength = s.isEmpty();
+            return Property.implies(!zeroLength, () -> {
+                long x = new BigInteger(s, 2).longValue();
+                long y = BitSet.stringBitSet(s).longValue();
+                return prop(x == y);
+            });
+        });
+    }
+
+    Gen<List<Boolean>> arbListBoolean = Gen.choose(0, MAX_BIT_SIZE).bind(i -> Gen.sequenceN(i, arbBoolean));
+
+    Property toListTest() {
+        return property(arbListBoolean, list -> {
+            List<Boolean> expected = list.dropWhile(Booleans.not);
+            List<Boolean> actual = listBitSet(list).toList();
+            return prop(Equal.listEqual(Equal.booleanEqual).eq(expected, actual));
+        });
+    }
+
+    Property clearTest() {
+        return property(arbLong, arbBitSetSize, (l, i) ->
+                prop(BitSet.longBitSet(l).clear(i).isSet(i) == false)
+        );
+    }
+
+    Property bitsUsedTest() {
+        return property(arbListBoolean, list -> prop(
+                    list.dropWhile(b -> !b).length() ==
+                    listBitSet(list).bitsUsed()
+        ));
+    }
+
+    Property isSetTest() {
+        return property(arbNaturalLong, Gen.choose(0, MAX_BIT_SIZE),
+                (Long l, Integer i) -> prop(longBitSet(l).isSet(i) == ((l & (1L << i)) != 0))
+        );
+    }
+
+    Property stringBitSet() {
+        return property(arbNaturalLong, l ->
+            prop(BitSet.stringBitSet(BitSet.longBitSet(l).asString()).longValue() == l)
+        );
+    }
+
+    Property notTest() {
+        return property(arbLong, l -> prop(longBitSet(l).not().longValue() == ~l));
+    }
+
+    Property orTest() {
+        return property(arbLong, arbLong, (x, y) -> prop(
+                longBitSet(x).or(longBitSet(y)).longValue() == (x | y)
+        ));
+    }
+
+    Gen<List<Integer>> bitSetIndices(int n) {
+        return Gen.listOfSorted(Gen.choose(0, MAX_BIT_SIZE - 1), n, Ord.intOrd);
+    }
+
+    Property rangeTest() {
+        return property(arbNaturalLong, bitSetIndices(4), (x, list) -> {
+            int l = list.index(0);
+            int m = list.index(1);
+            int h = list.index(2);
+            int vh = list.index(3);
+
+            BitSet bs1 = longBitSet(x);
+            BitSet bs2 = bs1.range(l, h);
+            boolean b =
+                bs1.isSet(m) == bs2.isSet(m - l) &&
+                bs2.isSet(vh - l) == false;
+            return prop(b);
+        });
+    }
+
+    Property setTest() {
+        return property(arbNaturalLong, arbBitSetSize, (l, i) -> prop(longBitSet(l).set(i).isSet(i)));
+    }
+
+    Property setBooleanTest() {
+        return property(arbNaturalLong, arbBitSetSize, arbBoolean, (l, i, b) -> prop(longBitSet(l).set(i, b).isSet(i) == b));
+    }
+
+    Property shiftLeftTest() {
+        return property(arbNaturalLong, arbBitSetSize, (l, i) -> {
+            BitSet bs = longBitSet(l);
+            boolean b = bs.shiftLeft(i).longValue() == (l << i);
+            return impliesBoolean(bs.bitsUsed() + i < MAX_BIT_SIZE, b);
+        });
+    }
+
+    Property shiftRightTest() {
+        return property(arbNaturalLong, arbBitSetSize, (l, i) -> {
+            return prop(longBitSet(l).shiftRight(i).longValue() == (l >> i));
+        });
+    }
+
+    Property takeLowerTest() {
+        return property(arbNaturalLong, arbBitSetSize, (l, i) -> {
+            return prop(bitSetSequal.eq(longBitSet(l).takeLower(i), longBitSet(l).range(0, i)));
+        });
+    }
+
+    Property takeUpperTest() {
+        return property(arbNaturalLong, arbBitSetSize, (l, i) -> {
+            return prop(bitSetSequal.eq(longBitSet(l).takeUpper(i), longBitSet(l).range(MAX_BIT_SIZE, MAX_BIT_SIZE - i)));
+        });
+    }
+
+    Property toStreamTest() {
+        return property(arbNaturalLong, l -> {
+            return prop(listEqual(booleanEqual).eq(longBitSet(l).toList(), longBitSet(l).toStream().toList()));
+        });
+    }
+
+    Property xorTest() {
+        return property(arbNaturalLong, arbNaturalLong, (a, b) -> {
+            return prop(longBitSet(a).xor(longBitSet(b)).longValue() == (a ^ b));
+        });
+    }
+    static final Gen<Long> arbNaturalLong = Gen.choose(0, Long.MAX_VALUE);
+
+    static final Gen<Integer> arbBitSetSize = Gen.choose(0, MAX_BIT_SIZE - 1);
+
+}
diff --git a/props-core/src/test/java/fj/data/hamt/HashArrayMappedTrieProperties.java b/props-core/src/test/java/fj/data/hamt/HashArrayMappedTrieProperties.java
new file mode 100644
index 00000000..05001a1a
--- /dev/null
+++ b/props-core/src/test/java/fj/data/hamt/HashArrayMappedTrieProperties.java
@@ -0,0 +1,94 @@
+package fj.data.hamt;
+
+import fj.Equal;
+import fj.Hash;
+import fj.Ord;
+import fj.P2;
+import fj.data.List;
+import fj.data.Option;
+import fj.data.Set;
+import fj.test.Gen;
+import fj.test.Property;
+import fj.test.reflect.CheckParams;
+import fj.test.runner.PropertyTestRunner;
+import org.junit.runner.RunWith;
+
+import static fj.Equal.intEqual;
+import static fj.Equal.optionEqual;
+import static fj.Ord.intOrd;
+import static fj.Ord.p2Ord;
+import static fj.Ord.p2Ord2;
+import static fj.data.Option.some;
+import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbList;
+import static fj.test.Arbitrary.arbListInteger;
+import static fj.test.Arbitrary.arbP2;
+import static fj.test.Arbitrary.arbSet;
+import static fj.test.Property.prop;
+import static fj.test.Property.property;
+
+/**
+ * @author Mark Perry
+ */
+@RunWith(PropertyTestRunner.class)
+@CheckParams(maxSize = 100)
+public class HashArrayMappedTrieProperties {
+
+    private static final HashArrayMappedTrie<Integer, Integer> empty = HashArrayMappedTrie.emptyKeyInteger();
+    private static final Gen<List<P2<Integer, Integer>>> arbListProducts = arbSet(intOrd, arbInteger).bind(s -> Gen.listOf(arbInteger, s.size()).map(list -> s.toList().zip(list)));
+    private static final Gen<HashArrayMappedTrie<Integer, Integer>> arbHamt = arbListProducts.map(l -> empty.set(l));
+
+    Property empty() {
+        return prop(empty.isEmpty());
+    }
+
+    Property setFromList() {
+        return property(arbListProducts, list -> {
+            List<P2<Integer, Integer>> actual = empty.set(list).toList(intOrd);
+            List<P2<Integer, Integer>> expected = list.sort(p2Ord(intOrd, intOrd));
+            boolean b = actual.equals(expected);
+            return prop(b);
+        });
+    }
+
+    Property overwriteKey() {
+        return property(arbHamt, arbInteger, arbInteger, arbInteger, (h, k, v1, v2) -> {
+            Option<Integer> actual = h.set(k, v1).set(k, v2).find(k);
+            return prop(optionEqual(intEqual).eq(actual, some(v2)));
+        });
+    }
+
+    Property allIn() {
+        return property(arbListProducts, list -> {
+            HashArrayMappedTrie<Integer, Integer> h = empty.set(list);
+            Boolean b = list.foldLeft((acc, p) -> h.find(p._1()).option(false, i -> true && acc), true);
+            return prop(b);
+        });
+    }
+
+    Property sampleInts() {
+        return property(arbListProducts, arbInteger, (ps, i) -> {
+            HashArrayMappedTrie<Integer, Integer> h = empty.set(ps);
+            Option<Integer> o1 = ps.find(p -> intEqual.eq(p._1(), i)).map(p -> p._2());
+            Option<Integer> o2 = h.find(i);
+            return prop(optionEqual(intEqual).eq(o1, o2));
+        });
+    }
+
+    Property fold() {
+        return property(arbListProducts, list -> {
+            Integer actual = empty.set(list).foldLeft((acc, p) -> acc + p._2(), 0);
+            Integer expected = list.foldLeft((acc, p) -> acc + p._2(), 0);
+            return prop(intEqual.eq(actual, expected));
+        });
+    }
+
+    Property length() {
+        return property(arbListProducts, list -> {
+            Integer actual = empty.set(list).length();
+            Integer expected = list.length();
+            return prop(intEqual.eq(actual, expected));
+        });
+    }
+
+}
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 1e4a4c5e..5b0a98bc 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -363,6 +363,12 @@ public static Gen<Integer> choose(final int from, final int to) {
     return parameterised(curry((i, r) -> value(r.choose(f, t))));
   }
 
+  public static Gen<Long> choose(final long from, final long to) {
+    final long f = min(from, to);
+    final long t = max(from, to);
+    return parameterised(i -> r -> value(r.choose(f, t)));
+  }
+
   /**
    * Returns a generator that produces values between the given range (inclusive).
    *
@@ -468,6 +474,10 @@ public static <A> Gen<List<A>> listOf(final Gen<A> g, final int x) {
     return sized(size -> choose(x, max(x, size)).bind(n -> sequenceN(n, g)));
   }
 
+  public static <A> Gen<List<A>> listOfSorted(final Gen<A> g, final int x, Ord<A> ord) {
+    return listOf(g, x).map(l -> l.sort(ord));
+  }
+
   /**
    * Returns a generator of lists whose values come from the given generator.
    *
diff --git a/quickcheck/src/main/java/fj/test/Rand.java b/quickcheck/src/main/java/fj/test/Rand.java
index f1849bb3..b622dfe7 100644
--- a/quickcheck/src/main/java/fj/test/Rand.java
+++ b/quickcheck/src/main/java/fj/test/Rand.java
@@ -55,6 +55,9 @@ public int choose(final int from, final int to) {
     return f.f(Option.none()).f(from).f(to);
   }
 
+  public long choose(final long from, final long to) {
+    return g.f(Option.none()).f((double) from).f((double) to).longValue();
+  }
   /**
    * Randomly chooses a value between the given range (inclusive).
    *
diff --git a/quickcheck/src/test/java/fj/test/TestRand.java b/quickcheck/src/test/java/fj/test/TestRand.java
index 6c72b3b1..1ca7c749 100644
--- a/quickcheck/src/test/java/fj/test/TestRand.java
+++ b/quickcheck/src/test/java/fj/test/TestRand.java
@@ -20,7 +20,7 @@ public void testRandLowHighInclusive() {
         int max = 10;
         int n = 100;
         Stream<Integer> s = Stream.range(0, n).map(i -> Rand.standard.choose(min, max)).sort(Ord.intOrd);
-//        System.out.println(s);
+//        System.out.println(s.toList());
         assertTrue(s.head() == min && s.last() == max);
     }
 

From 732a15176efbee751abfbeb97d82f3029d8cc9a1 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 17:35:16 +0100
Subject: [PATCH 152/336] rename  Ord/Equal.AltDef

---
 core/src/main/java/fj/Equal.java | 6 +++---
 core/src/main/java/fj/Ord.java   | 9 ++++-----
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index ae20c4df..35232412 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -53,7 +53,7 @@ default boolean equal(A a1, A a2) {
   /**
    * Primitives functions of Equal: alternative minimal definition and overridable methods.
    */
-  public interface AlternateDefinition<A> extends Definition<A> {
+  public interface AltDefinition<A> extends Definition<A> {
 
     @Override
     boolean equal(A a1, A a2);
@@ -158,7 +158,7 @@ public static <A> Equal<A> equalDef(final Definition<A> definition) {
    * @param definition a definition of the equal instance.
    * @return An equal instance from the given function.
    */
-  public static <A> Equal<A> equalDef(final AlternateDefinition<A> definition) {
+  public static <A> Equal<A> equalDef(final AltDefinition<A> definition) {
     return new Equal<>(definition);
   }
 
@@ -407,7 +407,7 @@ public static <A> Equal<Array<A>> arrayEqual(final Equal<A> ea) {
    */
   public static <A> Equal<Tree<A>> treeEqual(final Equal<A> ea) {
     Definition<A> eaDef = ea.def;
-    return equalDef(new AlternateDefinition<Tree<A>>() {
+    return equalDef(new AltDefinition<Tree<A>>() {
 
       final Definition<P1<Stream<Tree<A>>>> subForestEqDef = p1Equal(streamEqual(equalDef(this))).def;
 
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 1764ea74..5fdb6046 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -16,7 +16,6 @@
 
 import static fj.Function.apply;
 import static fj.Function.compose;
-import static fj.Function.compose2;
 import static fj.Function.curry;
 import static fj.Semigroup.semigroup;
 import static fj.Semigroup.semigroupDef;
@@ -90,7 +89,7 @@ public Definition<A> dual() {
   /**
    * Primitives functions of Ord: alternative minimal definition and overridable methods.
    */
-  public interface AlternateDefinition<A> extends Definition<A> {
+  public interface AltDefinition<A> extends Definition<A> {
 
     Ordering compare(A a1, A a2);
 
@@ -301,7 +300,7 @@ public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
   }
 
   /**
-   * Returns an order instance that uses the given minimal equality test and ordering definiion.
+   * Returns an order instance that uses the given minimal equality test and ordering definition.
    *
    * @param def The order definition.
    * @return An order instance.
@@ -311,12 +310,12 @@ public static <A> Ord<A> ordDef(final Definition<A> def) {
   }
 
   /**
-   * Returns an order instance that uses the given minimal equality test and ordering definiion.
+   * Returns an order instance that uses the given minimal equality test and ordering definition.
    *
    * @param def The order definition.
    * @return An order instance.
    */
-  public static <A> Ord<A> ordDef(final AlternateDefinition<A> def) {
+  public static <A> Ord<A> ordDef(final AltDefinition<A> def) {
     return new Ord<>(def);
   }
 

From 5f73cac759e57aba717420fa3d86d380ca783e45 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 17:50:38 +0100
Subject: [PATCH 153/336] List.minimum/maximum: use uncurried Ord.max/min for
 better perf.

---
 core/src/main/java/fj/data/List.java           | 4 ++--
 demo/src/main/java/fj/demo/euler/Problem4.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 8bc31a37..fa82359f 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -1462,7 +1462,7 @@ public static <A> F<List<A>, Integer> length_() {
    * @return The maximum element in this list according to the given ordering.
    */
   public final A maximum(final Ord<A> o) {
-    return foldLeft1(o.max);
+    return foldLeft1(o::max);
   }
 
   /**
@@ -1472,7 +1472,7 @@ public final A maximum(final Ord<A> o) {
    * @return The minimum element in this list according to the given ordering.
    */
   public final A minimum(final Ord<A> o) {
-    return foldLeft1(o.min);
+    return foldLeft1(o::min);
   }
 
   public final java.util.List<A> toJavaList() {
diff --git a/demo/src/main/java/fj/demo/euler/Problem4.java b/demo/src/main/java/fj/demo/euler/Problem4.java
index 60c04d85..c768ed78 100644
--- a/demo/src/main/java/fj/demo/euler/Problem4.java
+++ b/demo/src/main/java/fj/demo/euler/Problem4.java
@@ -19,6 +19,6 @@ public static void main(final String[] a) {
     intShow.println(tdl.tails().bind(tdl.zipWith(multiply)).filter(i -> {
         final Stream<Character> s = intShow.show(i);
         return streamEqual(charEqual).eq(s.reverse().take(3), s.take(3));
-    }).foldLeft1(intOrd.max));
+    }).foldLeft1(intOrd::max));
   }
 }

From 05275dbf41969b88b6f46426350e1d0662b2a78d Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 18:27:54 +0100
Subject: [PATCH 154/336] Do not deprecate monoid/ord/semigroup constructors
 for non java 8 users.

---
 core/src/main/java/fj/Equal.java              | 15 ++++
 core/src/main/java/fj/Monoid.java             | 14 +++-
 core/src/main/java/fj/Ord.java                | 16 +++-
 core/src/main/java/fj/Semigroup.java          | 12 ++-
 .../java/fj/demo/concurrent/WordCount.java    | 74 +++++++++----------
 5 files changed, 83 insertions(+), 48 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 35232412..b64c758d 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -135,6 +135,8 @@ public boolean equal(B b1, B b2) {
   /**
    * Constructs an equal instance from the given function.
    *
+   * Java 8+ users: use {@link #equalDef(Definition)} instead.
+   *
    * @param f The function to construct the equal with.
    * @return An equal instance from the given function.
    */
@@ -142,6 +144,19 @@ public static <A> Equal<A> equal(final F<A, F<A, Boolean>> f) {
     return new Equal<>(f::f);
   }
 
+
+  /**
+   * Constructs an equal instance from the given function.
+   *
+   * Java 8+ users: use {@link #equalDef(AltDefinition)} instead.
+   *
+   * @param f The function to construct the equal with.
+   * @return An equal instance from the given function.
+   */
+  public static <A> Equal<A> equal(final F2<A, A, Boolean> f) {
+    return equalDef(f::f);
+  }
+
   /**
    * Constructs an equal instance from the given definition.
    *
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index a342b8c7..3fcf1775 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -38,6 +38,9 @@ public final class Monoid<A> {
 
   private final Definition<A> def;
 
+  /**
+   * Primitives functions of Monoid: minimal definition and overridable methods.
+   */
   public interface Definition<A> extends Semigroup.Definition<A> {
 
     A empty();
@@ -91,6 +94,10 @@ public Definition<A> dual() {
     }
   }
 
+
+  /**
+   * Primitives functions of Monoid: alternative minimal definition and overridable methods.
+   */
   public interface AltDefinition<A> extends Definition<A> {
 
     @Override
@@ -423,13 +430,12 @@ public static <A> Monoid<A> monoidDef(final Semigroup.AltDefinition<A> s, final
   /**
    * Constructs a monoid from the given sum function and zero value, which must follow the monoidal
    * laws.
-   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} instead.
+   * Java 8+ users: use {@link #monoidDef(Semigroup.Definition, Object)} instead.
    *
    * @param sum  The sum function for the monoid.
    * @param zero The zero for the monoid.
    * @return A monoid instance that uses the given sun function and zero value.
    */
-  @Deprecated
   public static <A> Monoid<A> monoid(final F<A, F<A, A>> sum, final A zero) {
     return new Monoid<>(new AltDefinition<A>() {
       @Override
@@ -447,13 +453,13 @@ public A empty() {
   /**
    * Constructs a monoid from the given sum function and zero value, which must follow the monoidal
    * laws.
-   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} instead.
+   *
+   * Java 8+ users: use {@link #monoidDef(Semigroup.Definition, Object)} instead.
    *
    * @param sum  The sum function for the monoid.
    * @param zero The zero for the monoid.
    * @return A monoid instance that uses the given sun function and zero value.
    */
-  @Deprecated
   public static <A> Monoid<A> monoid(final F2<A, A, A> sum, final A zero) {
     return new Monoid<>(new Definition<A>() {
       @Override
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 5fdb6046..a3e55edc 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -290,15 +290,27 @@ public final Ord<A> reverse() {
   /**
    * Returns an order instance that uses the given equality test and ordering function.
    *
-   * @deprecated since 4.7. Use {@link #ordDef(Definition)}.
+   * Java 8+ users: use {@link #ordDef(Definition)} instead.
+   *
    * @param f The order function.
    * @return An order instance.
    */
-  @Deprecated
   public static <A> Ord<A> ord(final F<A, F<A, Ordering>> f) {
     return new Ord<>(f::f);
   }
 
+  /**
+   * Returns an order instance that uses the given equality test and ordering function.
+   *
+   * Java 8+ users: use {@link #ordDef(AltDefinition)} instead.
+   *
+   * @param f The order function.
+   * @return An order instance.
+   */
+  public static <A> Ord<A> ord(final F2<A, A, Ordering> f) {
+    return ordDef(f::f);
+  }
+
   /**
    * Returns an order instance that uses the given minimal equality test and ordering definition.
    *
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index cba1f04b..74d7de9b 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -31,6 +31,9 @@
  */
 public final class Semigroup<A> {
 
+  /**
+   * Primitives functions of Semigroup: minimal definition and overridable methods.
+   */
   public interface Definition<A> {
 
     A append(A a1, A a2);
@@ -79,6 +82,9 @@ public A multiply1p(int n, A a) {
     }
   }
 
+  /**
+   * Primitives functions of Semigroup: alternative minimal definition and overridable methods.
+   */
   public interface AltDefinition<A> extends Definition<A> {
     @Override
     F<A, A> prepend(A a);
@@ -285,24 +291,22 @@ public static <A> Semigroup<A> semigroupDef(final AltDefinition<A> def) {
 
   /**
    * Constructs a semigroup from the given function.
-   * @deprecated since 4.7. Use {@link #semigroupDef(Definition)}.
+   * Java 8+ users: use {@link #semigroupDef(AltDefinition)} instead.
    *
    * @param sum The function to construct this semigroup with.
    * @return A semigroup from the given function.
    */
-  @Deprecated
   public static <A> Semigroup<A> semigroup(final F<A, F<A, A>> sum) {
     return semigroupDef(sum::f);
   }
 
   /**
    * Constructs a semigroup from the given function.
-   * @deprecated since 4.7. Use {@link #semigroupDef(Definition)}.
+   * Java 8+ users: use {@link #semigroupDef(Definition)} instead.
    *
    * @param sum The function to construct this semigroup with.
    * @return A semigroup from the given function.
    */
-  @Deprecated
   public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
     return new Semigroup<>(sum::f);
   }
diff --git a/demo/src/main/java/fj/demo/concurrent/WordCount.java b/demo/src/main/java/fj/demo/concurrent/WordCount.java
index c90a0b2d..175d2d09 100644
--- a/demo/src/main/java/fj/demo/concurrent/WordCount.java
+++ b/demo/src/main/java/fj/demo/concurrent/WordCount.java
@@ -1,10 +1,18 @@
 package fj.demo.concurrent;
 
-import static fj.Monoid.monoid;
-import static fj.Monoid.monoidDef;
-import static fj.control.parallel.ParModule.parModule;
-import static fj.data.List.nil;
-import static java.util.concurrent.Executors.newFixedThreadPool;
+import fj.F;
+import fj.Monoid;
+import fj.P;
+import fj.P1;
+import fj.P2;
+import fj.control.parallel.ParModule;
+import fj.control.parallel.Promise;
+import fj.control.parallel.Strategy;
+import fj.data.IOFunctions;
+import fj.data.Iteratee.Input;
+import fj.data.Iteratee.IterV;
+import fj.data.List;
+import fj.data.Option;
 
 import java.io.BufferedWriter;
 import java.io.File;
@@ -14,35 +22,25 @@
 import java.io.Reader;
 import java.io.StringWriter;
 import java.io.Writer;
-import java.nio.charset.Charset;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 
-import fj.F;
-import fj.Monoid;
-import fj.P;
-import fj.P1;
-import fj.P2;
-import fj.Unit;
-import fj.control.parallel.ParModule;
-import fj.control.parallel.Promise;
-import fj.control.parallel.Strategy;
-import fj.data.*;
-import fj.data.Iteratee.Input;
-import fj.data.Iteratee.IterV;
-import fj.function.Effect1;
+import static fj.Monoid.monoid;
+import static fj.control.parallel.ParModule.parModule;
+import static fj.data.List.nil;
+import static java.util.concurrent.Executors.newFixedThreadPool;
 
 /**
  * Reads words and their counts from files ({@link #getWordsAndCountsFromFiles} in a single thread
  * and {@link #getWordsAndCountsFromFilesInParallel} in multiple threads). The files are created
  * initially and populated with some sample content.
- * 
+ *
  * @author Martin Grotzke
  */
 public class WordCount {
-  
+
   // Integers.add.f(1) caused an SOE...
   private static final F<Integer,Integer> addOne = a -> a.intValue() + 1;
 
@@ -55,7 +53,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
     map.put(key, valueFunction.f(value));
     return map;
   }
-  
+
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharChunkIteratee = fileName -> {
       try {
         return IOFunctions.enumFileCharChunks(new File(fileName), Option.none(), wordCountsFromCharChunks()).run().run();
@@ -63,7 +61,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
         throw new RuntimeException(e);
       }
   };
-  
+
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharChunk2Iteratee = fileName -> {
       try {
         return IOFunctions.enumFileChars(new File(fileName), Option.none(), wordCountsFromChars()).run().run();
@@ -71,7 +69,7 @@ private static <K, V> Map<K, V> update(Map<K, V> map, K key, F<V, V> valueFuncti
         throw new RuntimeException(e);
       }
   };
-  
+
   private static final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithCharIteratee = fileName -> {
       try {
         return IOFunctions.enumFileChars(new File(fileName), Option.none(), wordCountsFromChars()).run().run();
@@ -181,7 +179,7 @@ public static void main(String[] args) throws IOException {
     final Map<String, Integer> expectedWordsAndCounts = result._2();
     long avgSize = fileNames.foldLeft((a, file) -> a.longValue() + new File(file).length(), 0l) / fileNames.length();
     System.out.println("Processing " + numFiles + " files with ~"+numSharedWords+" words and an avg size of " + avgSize + " bytes.");
-    
+
     // warmup
     for(int i = 0; i < 1; i++) {
       // getWordsAndCountsFromFiles(fileNames.take(1)).size();
@@ -211,7 +209,7 @@ public static void main(String[] args) throws IOException {
     assertTrue(wordsAndCountsFromFiles != null);
     assertEquals(wordsAndCountsFromFiles.size(), numFiles + numSharedWords);
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
-    
+
     System.gc();
 
     // get word counts sequentially / single threaded \w iteratee
@@ -223,7 +221,7 @@ public static void main(String[] args) throws IOException {
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
 
     System.gc();
-    
+
     // get word counts sequentially / single threaded \w iteratee
     start = System.currentTimeMillis();
     wordsAndCountsFromFiles = getWordsAndCountsFromFilesWithIteratee(fileNames, fileNameToWordsAndCountsWithCharChunk2Iteratee);
@@ -233,7 +231,7 @@ public static void main(String[] args) throws IOException {
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
 
     System.gc();
-    
+
 //    start = System.currentTimeMillis();
 //    wordsAndCountsFromFiles = getWordsAndCountsFromFilesInParallel(fileNames, fileNameToWordsAndCounts, 8);
 //    System.out.println("Getting word counts in 8 threads took " + (System.currentTimeMillis() - start) + " ms.");
@@ -249,14 +247,14 @@ public static void main(String[] args) throws IOException {
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
 
     System.gc();
-    
+
     start = System.currentTimeMillis();
     wordsAndCountsFromFiles = getWordsAndCountsFromFilesInParallel(fileNames, fileNameToWordsAndCountsWithCharChunkIteratee, 32);
     System.out.println("Getting word counts in 32 threads with char chunk iteratee took " + (System.currentTimeMillis() - start) + " ms.");
     assertTrue(wordsAndCountsFromFiles != null);
     assertEquals(wordsAndCountsFromFiles.size(), numFiles + numSharedWords);
     assertEquals(wordsAndCountsFromFiles, expectedWordsAndCounts);
-    
+
     // we have tmpfiles, but still want to be sure not to leave rubbish
     fileNames.foreachDoEffect(a -> new File(a).delete());
   }
@@ -286,13 +284,13 @@ private static P2<List<String>, Map<String, Integer>> writeSampleFiles(
     }
     return P.p(fileNames, expectedWordsAndCounts);
   }
-  
+
   public static Map<String, Integer> getWordsAndCountsFromFilesWithIteratee(final List<String> fileNames,
       final F<String, Map<String, Integer>> fileNameToWordsAndCountsWithIteratee) {
     final List<Map<String, Integer>> maps = fileNames.map(fileNameToWordsAndCountsWithIteratee);
     return maps.foldLeft(WordCount::plus, new HashMap<String, Integer>());
   }
-  
+
   public static Map<String, Integer> getWordsAndCountsFromFilesInParallel(
       final List<String> fileNames, final F<String, Map<String, Integer>> fileNameToWordsAndCounts, int numThreads) {
     final ExecutorService pool = newFixedThreadPool(numThreads);
@@ -305,14 +303,14 @@ public static Map<String, Integer> getWordsAndCountsFromFilesInParallel(
 
     return result;
   }
-  
+
   // Read documents and extract words and word counts of documents
   public static Promise<Map<String, Integer>> getWordsAndCountsFromFiles(
       final List<String> fileNames, final F<String, Map<String, Integer>> fileNameToWordsAndCounts, final ParModule m) {
-    final Monoid<Map<String, Integer>> monoid = monoidDef(WordCount::plus, Collections.emptyMap());
+    final Monoid<Map<String, Integer>> monoid = monoid(WordCount::plus, Collections.emptyMap());
     return m.parFoldMap(fileNames, fileNameToWordsAndCounts, monoid);
   }
-  
+
   private static Map<String, Integer> plus(Map<String, Integer> a, Map<String, Integer> b) {
     final Map<String, Integer> result = new HashMap<>(a);
     for(Map.Entry<String, Integer> entry : b.entrySet()) {
@@ -321,7 +319,7 @@ private static Map<String, Integer> plus(Map<String, Integer> a, Map<String, Int
     }
     return result;
   }
-  
+
   @SuppressWarnings("unused")
   private static String readFileToString(File file) throws IOException {
         Reader reader = null;
@@ -342,13 +340,13 @@ private static void copy(Reader reader, Writer writer) throws IOException {
         writer.write(buffer, 0, n);
     }
   }
-  
+
   static void assertTrue(boolean condition) {
     if (!condition) {
       throw new AssertionError();
     }
   }
-  
+
   static void assertEquals(Object actual, Object expected) {
     if (!expected.equals(actual)) {
       throw new IllegalArgumentException("Not equals. Expected: " + expected + ", actual: " + actual);

From 3d57ed7383409a8ca7d8201be1e1199f46a962d8 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 18:48:05 +0100
Subject: [PATCH 155/336] retrolambda: enable backport of default methods.

---
 lib.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib.gradle b/lib.gradle
index 5b84e98b..28be5e34 100644
--- a/lib.gradle
+++ b/lib.gradle
@@ -89,6 +89,7 @@ void configureRetroLambda(boolean useRetroLambda, String newJdkEnvVar, String ol
             jdk System.getenv(newJdkEnvVar)
             oldJdk System.getenv(oldJdkEnvVar)
             javaVersion retroLambdaTarget
+            defaultMethods true
         }
         dependencies {
             retrolambdaConfig "net.orfjackal.retrolambda:retrolambda:$retrolambdaVersion"

From f583adb8f6fad8f2fcb46bcbd6707e4e0590cc69 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 6 Nov 2016 20:32:34 +0100
Subject: [PATCH 156/336] Fix BitSet.range property checking.

---
 props-core/src/test/java/fj/data/hamt/BitSetProperties.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
index 0ae976ef..f3527972 100644
--- a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
+++ b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
@@ -153,8 +153,8 @@ Gen<List<Integer>> bitSetIndices(int n) {
     Property rangeTest() {
         return property(arbNaturalLong, bitSetIndices(4), (x, list) -> {
             int l = list.index(0);
-            int m = list.index(1);
             int h = list.index(2);
+            int m = Math.max(l, Math.min(list.index(1), h - 1));
             int vh = list.index(3);
 
             BitSet bs1 = longBitSet(x);

From b897b745636d51218bcd8d8ffaa7275fa4bb2423 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Tue, 6 Dec 2016 21:42:53 -0500
Subject: [PATCH 157/336] Upgrade Gradle to 2.14.1

---
 gradle/wrapper/gradle-wrapper.jar        | Bin 51106 -> 53637 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 ++--
 gradlew                                  |  10 +++-------
 3 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 3c7abdf12790879c06b07176de29647f77aa4129..05ef575b0cd0173fc735f2857ce4bd594ce4f6bd 100644
GIT binary patch
delta 40807
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

delta 38360
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a54a2d93..23175860 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Tue Jun 10 12:02:45 EST 2014
+#Tue Dec 06 21:53:19 EST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-bin.zip
diff --git a/gradlew b/gradlew
index 91a7e269..9d82f789 100755
--- a/gradlew
+++ b/gradlew
@@ -42,11 +42,6 @@ case "`uname`" in
     ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +56,9 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -114,6 +109,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`

From bb1663394fd8f15e25041b745184bc970fc44c22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Wed, 7 Dec 2016 18:21:47 -0500
Subject: [PATCH 158/336] Switch coverage to cover.io

---
 .travis.yml | 2 +-
 README.adoc | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index bf8f8d78..4a7c9290 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -30,4 +30,4 @@ script:
   - ./gradlew build coverage -s -i
 
 after_success:
-  - ./gradlew jacocoRootReport coveralls
+  - bash <(curl -s https://codecov.io/bash)
diff --git a/README.adoc b/README.adoc
index 9addaff8..418605de 100644
--- a/README.adoc
+++ b/README.adoc
@@ -1,7 +1,7 @@
 = Functional Java
 
 image:https://travis-ci.org/functionaljava/functionaljava.svg?branch=master["Build Status", link="https://travis-ci.org/functionaljava/functionaljava"]
-image:https://coveralls.io/repos/github/functionaljava/functionaljava/badge.svg?branch=master["Coverage Status", link="https://coveralls.io/github/functionaljava/functionaljava?branch=master"]
+image:https://codecov.io/gh/functionaljava/functionaljava/branch/master/graph/badge.svg["Code Coverage", link="https://codecov.io/gh/functionaljava/functionaljava"]
 image:https://badges.gitter.im/functionaljava/functionaljava.svg[link="https://gitter.im/functionaljava/functionaljava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"]
 
 image::http://www.functionaljava.org/img/logo-600x144.png[]

From e95182ad090ff8c1bbdc9d4bd7bf37ba7ae5c4be Mon Sep 17 00:00:00 2001
From: JB Giraudeau <jb@giraudeau.info>
Date: Fri, 16 Dec 2016 08:54:46 +0100
Subject: [PATCH 159/336] Change coverage executionData on root project to use
 wildcard path (#310)

otherwise it is skipped because some sub-projects do not have execution Data.
Also only aggregate results for published artefacts.
Also removed unsused gradle task,
---
 build.gradle | 41 ++++++++---------------------------------
 1 file changed, 8 insertions(+), 33 deletions(-)

diff --git a/build.gradle b/build.gradle
index 7d9efae1..1ccd524a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,12 +20,10 @@ buildscript {
     dependencies {
         classpath "com.ofg:uptodate-gradle-plugin:$uptodateVersion"
         classpath "me.tatarka:gradle-retrolambda:$retrolambdaPluginVersion"
-        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.6.3'
     }
 }
 
 apply plugin: "jacoco"
-apply plugin: 'com.github.kt3k.coveralls'
 
 if (JavaVersion.current().isJava8Compatible()) {
     allprojects {
@@ -129,27 +127,24 @@ subprojects {
         reports {
             html.enabled = true
             xml.enabled = true
-            csv.enabled = false
-//        html.destination "${buildDir}/jacocoHtml"
         }
     }
 
-
-    task coverage(dependsOn: ["test", "jacocoTestReport"]) << {
-
-    }
+    task coverage(dependsOn: ["test", "jacocoTestReport"]) << {}
 
 }
 
 task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
-    dependsOn = subprojects.test
-    sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
-    classDirectories =  files(subprojects.sourceSets.main.output)
-    executionData = files(subprojects.jacocoTestReport.executionData)
+    dependsOn = subprojects.coverage
+    executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")
+    // We only care about coverage of:
+    def projectForFoverage = ["core", "java8", "quickcheck", "java-core"]
+    classDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.output)
+    sourceDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.allSource.srcDirs)
+
     reports {
         html.enabled = true
         xml.enabled = true
-        csv.enabled = false
     }
 }
 
@@ -210,23 +205,3 @@ configure(subprojects.findAll { it.name != "props-core" }) {
 task env << {
 	println System.getenv()
 }
-
-task jacocoRootReport(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
-	dependsOn = subprojects.jacocoTestReport
-	sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
-	classDirectories = files(subprojects.sourceSets.main.output)
-	executionData = files(subprojects.jacocoTestReport.executionData)
-	reports {
-		xml.enabled true
-		xml.destination ="${buildDir}/reports/jacoco/test/jacocoTestReport.xml"
-	}
-	// We could remove the following setOnlyIf line, but then
-	// jacocoRootReport would silently be SKIPPED if something with
-	// the projectsWithUnitTests is wrong (e.g. a project is missing
-	// in there).
-	setOnlyIf { true }
-}
-
-coveralls {
-	sourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs).files.absolutePath
-}

From 6ac5f9547dbb1f0ca3777be6b366f256e9943194 Mon Sep 17 00:00:00 2001
From: Shimi Bandiel <shimi@trainologic.com>
Date: Mon, 23 Jan 2017 21:22:20 +0200
Subject: [PATCH 160/336] Add NEL.minimum/maximum and safe versions of
 minimum/maximum for List

* added minimum/maximum on NEL && changed impl of minimumOption/maximumOption in List to use it

* spaces for tabs
---
 core/src/main/java/fj/data/List.java         | 20 ++++++++++++++++++
 core/src/main/java/fj/data/NonEmptyList.java | 22 ++++++++++++++++++++
 2 files changed, 42 insertions(+)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index fa82359f..f58fd73f 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -1465,6 +1465,16 @@ public final A maximum(final Ord<A> o) {
     return foldLeft1(o::max);
   }
 
+  /**
+   * Returns the maximum element in this list according to the given ordering.
+   *
+   * @param o An ordering for the elements of the list.
+   * @return The optional maximum element in this list according to the given ordering.
+   */
+  public final Option<A> maximumOption(final Ord<A> o) {
+    return NonEmptyList.fromList(this).map(nel -> nel.maximum(o));
+  }
+  
   /**
    * Returns the minimum element in this list according to the given ordering.
    *
@@ -1474,6 +1484,16 @@ public final A maximum(final Ord<A> o) {
   public final A minimum(final Ord<A> o) {
     return foldLeft1(o::min);
   }
+  
+  /**
+   * Returns the minimum element in this list according to the given ordering.
+   *
+   * @param o An ordering for the elements of the list.
+   * @return The optional minimum element in this list according to the given ordering.
+   */
+  public final Option<A> minimumOption(final Ord<A> o) {
+    return NonEmptyList.fromList(this).map(nel -> nel.minimum(o));
+  }
 
   public final java.util.List<A> toJavaList() {
     return new java.util.LinkedList<>(toCollection());
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index da06e0f4..4073476d 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -226,6 +226,28 @@ public NonEmptyList<A> sort(final Ord<A> o) {
     return nel(list.head(), list.tail());
   }
 
+  
+  /**
+   * Returns the minimum element in this non empty list according to the given ordering.
+   *
+   * @param o An ordering for the elements of this non empty list.
+   * @return The minimum element in this list according to the given ordering.
+   */
+  public final A minimum(final Ord<A> o) {
+    return foldLeft1(o::min);
+  }
+  
+  /**
+   * Returns the maximum element in this non empty list according to the given ordering.
+   *
+   * @param o An ordering for the elements of this non empty list.
+   * @return The maximum element in this list according to the given ordering.
+   */
+  public final A maximum(final Ord<A> o) {
+    return foldLeft1(o::max);
+  }
+  
+  
   /**
    * Zips this non empty list with the given non empty list to produce a list of pairs. If this list and the given list
    * have different lengths, then the longer list is normalised so this function never fails.

From 7417c434e29c0f62b15c93f9cfc6dd06c06764d0 Mon Sep 17 00:00:00 2001
From: siro-mateos <siromateos@gmail.com>
Date: Tue, 6 Dec 2016 17:45:08 +0100
Subject: [PATCH 161/336]  + Added 'Set.lookup', and 'Set.lookupLT',
 'Set.lookupGT','Set.lookupLE' and 'Set.lookupGE' from Haskell.  + Added some
 test cases for new Set.lookup* functionality.  * Changed 'get(K)' to use
 'Set.lookup' instead of 'Set.split', so it can run much faster.

---
 core/src/main/java/fj/data/Set.java     | 123 ++++++++++++++++++++++++
 core/src/main/java/fj/data/TreeMap.java |   3 +-
 core/src/test/java/fj/data/SetTest.java |  16 +++
 3 files changed, 140 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 35b3c683..15207d83 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -515,6 +515,129 @@ public final P3<Set<A>, Option<A>, Set<A>> split(final A a) {
     }
   }
 
+  /**
+   * Find element equal to the given one.
+   *
+   * @param a An element to compare with.
+   * @return Some element in this set equal to the given one, or None.
+   */
+  public final Option<A> lookup(final A a) {
+    Set<A> s = this;
+    while (true)
+      if (s.isEmpty())
+        return none();
+      else {
+        final A h = s.head();
+        final Ordering i = ord.compare(a, h);
+        if (i == LT)
+          s = s.l();
+        else if (i == GT)
+          s = s.r();
+        else
+          return some(h);
+      }
+  }
+
+  /**
+   * Find largest element smaller than the given one.
+   *
+   * @param a An element to compare with.
+   * @return Some largest element in this set smaller than the given one, or None.
+   */
+  public final Option<A> lookupLT(final A a) {
+    Set<A> s = this;
+    Option<A> r = none();
+    while (true)
+      if (s.isEmpty())
+        return r;
+      else {
+        final A h = s.head();
+        final Ordering i = ord.compare(a, h);
+        if (i == GT) {
+          r = some(h);
+          s = s.r();
+        }
+        else
+          s = s.l();
+      }
+  }
+
+  /**
+   * Find smallest element greater than the given one.
+   *
+   * @param a An element to compare with.
+   * @return Some smallest element in this set greater than the given one, or None.
+   */
+  public final Option<A> lookupGT(final A a) {
+    Set<A> s = this;
+    Option<A> r = none();
+    while (true)
+      if (s.isEmpty())
+        return r;
+      else {
+        final A h = s.head();
+        final Ordering i = ord.compare(a, h);
+        if (i == LT) {
+          r = some(h);
+          s = s.l();
+        }
+        else
+          s = s.r();
+      }
+  }
+
+  /**
+   * Find largest element smaller or equal to the given one.
+   *
+   * @param a An element to compare with.
+   * @return Some largest element in this set smaller or equal to the given one, or None.
+   */
+  public final Option<A> lookupLE(final A a) {
+    Set<A> s = this;
+    Option<A> r = none();
+    while (true)
+      if (s.isEmpty())
+        return r;
+      else {
+        final A h = s.head();
+        final Ordering i = ord.compare(a, h);
+        if (i == LT)
+          s = s.l();
+        else if (i == GT) {
+          r = some(h);
+          s = s.r();
+        }
+        else
+          return some(h);
+      }
+  }
+
+  /**
+   * Find smallest element greater or equal to the given one.
+   *
+   * @param a An element to compare with.
+   * @return Some smallest element in this set greater or equal to the given one, or None.
+   */
+  public final Option<A> lookupGE(final A a) {
+    Set<A> s = this;
+    Option<A> r = none();
+    while (true)
+      if (s.isEmpty())
+        return r;
+      else {
+        final A h = s.head();
+        final Ordering i = ord.compare(a, h);
+        if (i == LT) {
+          r = some(h);
+          s = s.l();
+        }
+        else if (i == GT)
+          s = s.r();
+        else
+          return some(h);
+      }
+  }
+
   /**
    * Returns true if this set is a subset of the given set.
    *
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index f663ab09..e5a3f06f 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -129,8 +129,7 @@ public static <K, V> TreeMap<K, V> arrayTreeMap(final Ord<K> keyOrd, final P2<K,
    * @return A potential value for the given key.
    */
   public Option<V> get(final K k) {
-    final Option<P2<K, Option<V>>> x = tree.split(p(k, Option.none()))._2();
-    return x.bind(P2.__2());
+    return tree.lookup(p(k, Option.none())).bind(P2::_2);
   }
 
   /**
diff --git a/core/src/test/java/fj/data/SetTest.java b/core/src/test/java/fj/data/SetTest.java
index 78084bb4..cdf2519c 100644
--- a/core/src/test/java/fj/data/SetTest.java
+++ b/core/src/test/java/fj/data/SetTest.java
@@ -2,6 +2,8 @@
 
 import org.junit.Test;
 
+import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static fj.Ord.intOrd;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
@@ -23,4 +25,18 @@ public void testString() {
 		assertThat(s.toString(), equalTo("Set(1,2,3)"));
 	}
 
+	@Test
+	public void testLookups() {
+		Set<Integer> s = Set.set(intOrd, 5, 1, 7, 8);
+		assertThat(s.lookup(7), equalTo(some(7)));
+		assertThat(s.lookup(4), equalTo(none()));
+		assertThat(s.lookupLT(6), equalTo(some(5)));
+		assertThat(s.lookupLT(1), equalTo(none()));
+		assertThat(s.lookupGT(5), equalTo(some(7)));
+		assertThat(s.lookupGT(9), equalTo(none()));
+		assertThat(s.lookupLE(8), equalTo(some(8)));
+		assertThat(s.lookupLE(0), equalTo(none()));
+		assertThat(s.lookupGE(8), equalTo(some(8)));
+		assertThat(s.lookupGE(9), equalTo(none()));
+	}
 }

From 443e01a12f2732e94f4b19d485dfb95cebd70075 Mon Sep 17 00:00:00 2001
From: siro-mateos <siromateos@gmail.com>
Date: Mon, 12 Dec 2016 23:27:18 +0100
Subject: [PATCH 162/336] Force strict evaluation in 'TreeMap.map'.

---
 core/src/main/java/fj/data/TreeMap.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index e5a3f06f..cd111d06 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -359,7 +359,7 @@ public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
    */
   @SuppressWarnings("unchecked")
   public <W> TreeMap<K, W> map(final F<V, W> f) {
-    final F<P2<K, Option<V>>, P2<K, Option<W>>> g = P2.map2_(F1Functions.mapOption(f));
+    final F<P2<K, Option<V>>, P2<K, Option<W>>> g = compose(p2 -> p(p2._1(), p2._2()), P2.map2_(F1Functions.mapOption(f)));
     final F<K, P2<K, Option<V>>> coord = flip(P.<K, Option<V>>p2()).f(Option.none());
     final Ord<K> o = tree.ord().contramap(coord);
     return new TreeMap<>(tree.map(TreeMap.ord(o), g));

From dd8451dd26d5ca9406e173b1ebaae02a74ae03e6 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Feb 2017 21:05:56 +0100
Subject: [PATCH 163/336] Fix typo. sofMemo -> softMemo

---
 core/src/main/java/fj/P.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index b0f3a31d..6d174ed7 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -61,7 +61,7 @@ public static <A> P1<A> weakMemo(F0<A> f) {
    * and at each subsequent call if and only if the reference have been garbage collected
    * due of shortage of memory (ie. to avoid OutOfMemoryErrors).
    */
-  public static <A> P1<A> sofMemo(F0<A> f) {
+  public static <A> P1<A> softMemo(F0<A> f) {
     return new P1.SoftReferenceMemo<>(f);
   }
 

From 9ca5ce35e7f83bbedfd707e8d67f1c7fc477ffdf Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 12:47:20 +0200
Subject: [PATCH 164/336] Update to gradle 3.4

---
 gradle/wrapper/gradle-wrapper.jar        | Bin 53637 -> 54208 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 +-
 gradlew                                  |  68 +++++++++++++----------
 gradlew.bat                              |  14 ++---
 props-core-scalacheck/build.gradle       |  10 +---
 5 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 05ef575b0cd0173fc735f2857ce4bd594ce4f6bd..7f9251933fd4846b7f2c971bb2c5f6a575ad3e3a 100644
GIT binary patch
delta 24962
zcmZ6SV~{05x2~Jhwr$(Sv~AnAy{B#4wr%(Bp7ykDThrE^bMJ{b=errTDk3W~^G{V|
zzVEYEg%*Pkl!GHG$$~?mgMdIogTVTc$s{5YA^uNq`6KW#kx!HN0_VZy&IJ_Yf5v|L
zlF5MlYheF%`_~};g`<ll6Zro(CUJ@c_W!N-Uo#S)X|VpMxBe9lItC2_l7a>TLY<rl
zftjp;2$h@%L<FR2M*5<ypnTUR(tB&e|Hf`$i39-`Nn-KrNJ7U`-F#DGz_VEx)t0sO
zjjX|_#@J=I7V#-L(_e2P=~eU@YcZPZfDtH^zj+t@P6){L?yk`=Dg66z^1R)X`J8<)
zJ*C@wpO0nuqk-TXajy}X5b0o=_54;0T5$q;KL;L0@eVMfE8=B~?FhGb#hN$DXU4vZ
zgA?t{7~(mh73GRR{>n(WJw5FEvg_;ZMdZ3eGz#S<ILk+LxD-C*m3D&kaGS`Sckl|<
zoPV+;IsAe>OLVe_X6%=AqIh?EhAfCSYPt4nw(;e}{Bi_qbtJmyjkLZGeKdXTqrPE4
zQ}hLQ)(~L%#75FXY>IT8;V(VPbu0g)m;M0u*gVCVBgRqMif1#MknsEp7w4J)ADam0
z98VDeq0A>NOp-$EO`)oMX(lHt|6ESDEH9sz*jTzfkx9p9o44#(CM#r__E(+g86lDg
z2b;UqOGS8RS5&5;kCorpwZOqyVgO9_sE_Kw*&bl9Fi%Gesr-imV}`^}HU@n<87=E<
zgQmZFmJ?f44|sGcl7I2ncC2L2C8!q2mGfEdliyN882rO{mUzso)^e7;N7dlm>K-}-
zJmE5vDs{RN%SGjr!=!x_Y;Z0b9OkVuno&J~Rf9JntF9W8DW}+hkX^C#+HEb0v$o)+
znJ|E9d=0AAWvTo`W!Et^Rm=4?vwnhJbk(L|P`M>;9e~p8#WFZ5=Ze-5Q5C}&xs+SY
zS~7%yC7aIR9k-GE1^Vezx2v`J;38~QCBbrZiWC~f4;&VEm`M{|J4o;8b9|ihBRFbY
z3O3cwELceo1nRI`(xalvN^MZ<m<%4?1UA5;-9+*aV*$m;>PogcqC+>wKBcD1D{vBe
zrGj$yNn31faXxiTdJ>d(z&%L`%+7cuS|eI}S|X7OQ@T3i$>aqqeDtL%+$XJXNmiOg
z6dr8FG5YJ;VR3NGAA2bndruW=V_*o<mp$yj3VIi=?qvmws323>EzgRudIOC|wKG8X
z<5E3mJ%>OE$Gm>Fvs-+^CfSC@vsv=0o34b#u%e+dmsVNYvJ!uk971s;VLD|t%=+;H
zNII^ble$3aeU+rEtO~7*V>tBot<QQG)Gk3WVsmKUG)&U2(Uld%-X~x68I|SDbjMt?
zYpz%PrRVHbk<$JbXS$XdMtZEw3KGE2D?KX4<w)-kXMsTa5QecdqjF|fnpJ6ppx`75
zyT=FH7k$$>bfdb_IeD&pi`%0yh|;4osQj1KD`T1fm=Q#@8(u<nL9@izT0zqhhX)Hw
z{2efoRYk5+#ZkLEMt=v(mfbt`w?)QLp^LqEmx@zDdQeeY&RdPC<cySEcNj36@%}&?
zhVTJr@sWfhFX*2Xv}&K?qK!iBpfJZK$ifkegR)SIUuj5#ZD|OY9_Sx*#Q2EQ?1!S*
znYUAapK2T|N1xhXoc43}DK+|IdNxg>xM3;)P`Z`;pa~J8dx4`8$22ARP#@g6eMbH&
z+|7SU4-o~IP$T#I8{;4^Nd%a)xSC|bY>5%9v|X#ndv-sw$Wk(>xx-D%o7O$oR`ko-
ztm8jj+uD5>Q%@D(=oe=pybuS&gyhjk4Qr#8{!`3dtn=kRu)%ZH^XN!39iShx$i%QL
zNH}S_bb~3&vBb}kqptSvMXJk-3+?GZ&-Ck>Uu`XMG&$s<ReR~C$pOko{|416F#5n`
zn+EgYXGiRGwjwHKkK%kOpeS1rXSiAD99;K>>_ESf{?_#fb`^r4H8h#7^ID&2hbJho
zh1dB3Y(=$teuyFxt7E-qJ$~PeuD&%!wxG0ZD6ee?P>(;r!|3jlNsupW1t4wiXBsm7
z_0<}$E28joc>av3a0U=voL&G}J}0b&;RpwU#d@PEc<spE62c9{-O|GiMBUoM`@&C$
z34H|S1PFb|NH+_t3HAsXEY8>2nMk($PpQU1i@KB*=?ct2=TE`TB@PnB%^@(6@fnKy
zV*cd(!Yi4>+zdgFjq-=CNBe_-?E*?9B6XW|=N*zib`HrNBLO%Zkk#VvqR#7sEsddA
z(bC>jlqAEP!={RXSpTy(m+H0&A{5ugct$)9X=TZ1AVIdrK+$8a*}$LI6C}m&3@H!8
zx(_x(m89878j#6t&OU2eswJUu#~#0A-ZE9Zw5@A;(;C^^`m`<ZwB3uIamv5EmVI$G
zjUdvnwY_0=V-G;}&1Ncc7xwB0J_!zPd#0fDdqiHw?`!jiXB>E9rOkE3_N)mDfwr4M
zdMLShCM`O2O$dy1#@G2W8N~Z%3<l&3gYtfZkl>F%ZpLGsuB(!|fEH<*K#YlzpE%{r
z2-k22BxyODEY1-Ltg+wMnxE+rOkbfFh!Kf1cn7Nn%>(vWvySI}^6Anr9MAEjS8QsC
ziS=g(^b!65Ak|P2*a2nmCg%u7dbtC+60W&WF$!Ku_T#&|7EF*x8xnuFdE51a@(`|R
zjK&?nt@6;Obx*A7XH$NbxPi!*G$m19;Fn^kvjXzCtMUq5?e5nhFL5X|Z!Q$cPa4y|
zp7lfc2LP^6TM7i`Ze&@~4Viw{9!qU12)_n!sk>rJC`C~0$~t5HjM0jQYFZu2>M#<^
z>SUfPO@fphvQi5HKC`)5Yd_iWh}s@30rt}Zm(I+W+|)mZOI-UFc!&-kTEolv!-KE)
zXyo`<#uMj$_Dz-4ehz#IOBRLJz3rA}c?pR$P63R0D2U0fn-n`?FazU~MPx(BT}dHH
z$+OFwSu^dGl)xN7xbM#3emn0LBnRwyiNGqQF1;z;mZ+~TVTaN15|UvMl#qqA{Fab;
zBhk)_?!t)F#H>AsuoxfYS5#9%hoYcXAA0%>OdD`tY=<~bT0xPUsqOt0<`s1Bu26NV
zs|e5<(7yLilX+8)0-7EU9%#vHuZB@Yey32yUDYxC*A>Um!yC&+8dn?gQV_9RgV&4R
z`ZLW2ZR_}}V8LDjT(5^q*FhdX?@6p>dTHzUH0`%R8ejnc`k(sg<WkGE>Yr}f_!p%A
zt)DDijLqzlb0Nn5mrgQyv8Fry0Rn=H2m(U+e|6F=HYUIj@1H<ol+w|zv8OlXGm<iw
zLn8sL+8VW&-%q1!Lxo7811gAMwqRaFq&9Uo6>9o)%HPll%y&KeCod;%{!x7J{jO-+
zS<{y-h@gD^c{A;s#r2STGnL)`{WW{>4d#US9ka(DBbrh-rZgZClSDI&fRm@GoN^_v
ztwk%tG6FFAt)N|kRn%baVWPA*;UONDP3r)3!q;W7n*^NPHc|@`4pZHZV+)32iNCc(
z&Hnya!&W$OW%V-v+G7|->_@YZ->RS+q8>3#-eR!)RZr~01g@BWNuck<?CY}l;q9QD
zFiGBRQTI_%8EV}5V+biZ*>$zlVNuDCwNAH2*#gq&A$69U;C+iK_~Q1cx!t`3>|A_o
z+^vmm0v;#q9BkZ;odx+^wSW4(g$1b2qPtfoXcvH1Ggs~2ijBMIZMmdBngErY%p3xq
zA}b?-Z<S<_y0ciZ6k`qbDV*ZNT&8KP@!8_Rl%(-lX=es1fAaA4G?25Xk19Rf)>~pS
zCjiG;#!Tn7;-VjLFXmgE<^*<On+VAj@8z-{BnRCSn@x`{YYl9!UEM6B6`YmU3v-Q!
z0W14gR)bE@4~<!N<`*;oi<XsX5#X}8r`s(<FJe!m)1IAwJq9Ghbc<UBaaS4NXbhv6
z!~^?9G=WFu2(ulabb?3^a$dc;#)$Lv7;xDe%&lu?P`e7G>uUZPiT^e)%Fxro@8`AP
zgx_l<mjyZOjPdtXCa%$-QQng;dE=eyaoBdFPR(+o)fp1jl)rK8d~vx;8Sy2OI}eU>
znUhnNE4Gqhr2#+wIN_+VI01n|b|z@*J?9bXH^cBW{j?<#wDzf9Q}iQgU%mW+IiO7c
zXN<&HCQ1C~SMZvZ8bAtlA{eeTs@LH+C7r(^LhNrCgkmqXVJK&1ARR8{tti6EZA(}=
zb2Uk{wZUO;8pj8;Cp$k>u4Wew&<jX^jG#LlFMdMxLW47I^^#d5ap#KAk9?NiQM~)X
zSMSt#M~BhB%p9z}eZF}}MjKGP2WWrEjoPt&0spGlQ+#O-VnkY{oHiew7Fl+Q4Jvqx
zrjFUK53-URyu-}Y__MH@Td!5uX?^+H>{+BnbBv}jE^pVsj8>*z*8$VdE-~^{9g{J%
zbL)xVd6yMdCFZBO>CVX|jKHyJdLKM98m(!}hBuzw76q{K(nn>E(qGOq1ALhTm8LT1
ziUEDLX}3r-Ms$^>@?(uGRvfS|dQg!1rzgjU#|MvX__r6AMtgBDWZG)ZEsl8VlgRcb
zCg`vObUk^gY0i`!tVue8EwgbQ;6x|Ca*gBfS$@C~4Qowm^z_%Z-#4@m+WJ;1JH37X
z#p$Oq>wUJ%)tVu|e+`VS0yMuuz$E7Fw%04UDB)_AsLWh23WOxDj6#}`6M;mKH-F7U
znzflXsnouCnOZszGj1iN&qenJ$MYVH<LNf90L`MEq{d0gn>_k$^W-da-%|;R(8KOT
z#F=>IpFWxh2zt8mgY3sRIQ<PyE>W9L9Ed>7a4cWc-SP~Lu1-hE039HZHz!pH(se=&
zmbv@!{s}HAzIM_0L<i@+IT$m0Y6uh6dFK>yEHlDHB3{TuMJ2B?FU+Id(SdgZ0|$%f
zTN&6=rG}!q!xJb&U_zxLA>PoRd8NsH9!ApSffU4)%s8tbOahfTj^*>}Ei1?qrC~PE
zvn62*9Ab=N9))$k0fuw9h*zX-Dxy%DIvC*xlH6|L+-lA(VKdQt?_Fb0XQR(&KJ!Wk
zN@iGNnkrj+*HQ@je2-2($a@)P)WO^`5{e}9e?(V@8nD(eh};BPHZn*BYA^!w4J;Vf
zz0N6H857b}8(u*4i8;_p?qO7r%W{Xkl2k&n{BpopC-g$O0Z1hg4ZTrl9634GV*9~F
zPlGq?6u0<jp4-D|_x6j82wvRiidpwb6?>qE{C4*DKOnbnZgX<*BlEk$p<LWn1=z$K
z1-iL=QAvxoao>2Ms=S=2+M`EgKH%AwzQZhE;Z?ut{5NBr@g<>5ug#j?&tB>M;rgCg
zzMy?r!sBnn08p=)V_=Orr9BZ8Oj(J%Zz%M>ryGY9NC|?n_B8EvZXb3S;PH>!Ke>C8
z9d2s(w-5~W4cHY~RTo-v$PSwGzC!?Q*M)FIkNg#jT7&BKzhBRgUz#czJbZqSiFT4m
z4-S+H^5U=KoWlud0*4Xesc>+xWiy<uVoH)%4_dZ=17sApY?1Pe@$H<s1J&zI*bPYU
zn6&pirFXw6^3WtG7w*h3g6oO1x}w{1-T04cc}q_Z&U}p+!#v3ue)f(?YEc=?nO$qX
z`)*r_ys=+A;`sQd@o1U5pZeBanGu|kF9*Tb_?|pW6{ryyN@x&tPkjF;S%8x<UA@k7
z{&y@Q!zU9#^8s{S@houy1hwbaFCIx8_BD9wl7%U#+LAD(66Gt3M}J1<bTpcrx3TNX
z8eYa~cAK=ym=L4GTJxl-%5ETM?1dRHPyNBEBKHb&f@IShzJ=?!MBtio`svlDzjjA+
zy~y?zceCfc^ZdHKwDa{mCIreIWq9U=UyA65inYjGy9bEo-S<)$j)^0ev3cmx>HQOj
zwe&&ZexHQPShZ))p@nO)p{y|(6=xuoTgGUeVLR3nM<C+|Wk-<SSm1z9px$wHo6@Vp
z*S85n<W2yJ%Uic=19o12GP01{5hjjcICra#V2F0gkT;p%$!$QL*Td~@?ALRfBW!rr
z<PMzRO#|?y=fe7J<l>>6PWU<qG;A8JyWpx6kTq1#+d`nZgDNAR)_KRNI)R@VHsZTy
z;J51YaWf`JVZmlv2YPK+D>ar|b>G_+^U{4Laa>3p&C==4v>a{N?C{1wJ#f~VMdt~n
z=RVX%ku_`jS8F5(JRP<+EmUl19(G*)ZgkOJz5t-5*-lI63ny!M5i_U7?Kkw+B;iGR
z#142gna?tC`5AWo<aFeTyXQ{Q#(3;pn{2|THoe!Ge!{}pw-#~fxepq+mikk=b>DN;
zHD4Kyhz$&qNzsdqi`0%55w}>fw%C!}MX}QSA|=~MOP^g8O!S6TsdwzesK*5oMPBLM
zxdQ^W2&SzWTIlMy#1i5;Q?3kklYr|k+K3LZJ}qjvJPQ7~6iKZEl$KJdG`=&fL1BuY
zk#i~zrbY398WnK`R{YE>9-NflBQP7z=!Wa_I2ty(OFB8J-ec91mUwOO_+{1Kf$_Jb
zw7lM#<h+W;8;!85umNwU)J&6b{7sQ4VF11(jt`gW-FHHTS>sYWBkUCf{2^m-QEqyp
znz*fjmAj~c;*0#<$gnH5631P<m$E?3I|fwiRT?Jjmo{GPQ3UY%J$LXO<zde|-nH9-
z(bur*?F$(-Fv)v^;mV9UtPFEQoj`Wmw23BdZHo-=@dtSz-vg?1=8rxsp0~ch1pqhM
z?dos`CGtZ(?h9x@#U28<&`>-AI!oam)sKLvd>FU1qHSZJbUBR4Y`+uApD8Eiz#f}5
z&;x|tdVUHvpGAw^P$QSJuy*(ld`DZav4QT6y1lYM!`+xL-5&vw7d4BNKy>Ukt*elD
zI{{76D0#_|Y<M=z(9P_b8o(*8IABIc-M~T7lJlZc`e>&XS>5O0Q6d%-Qq2;&=TvHU
zpiI#+mIQcr4t9at8-Fs~X0Zb9z<2dl6*n(BVA||HYYpKt4}1Jd&IvBz%S-Vvd1YqA
z)5U;0k;ed;Q9WQtA9m$_BU;;vds&r~ay*WE%%tpDQgbI>qDbe~y%1X41ZcOMycVIe
z^PhPus`W$l5X8qHzAYuI?a~W&v1ugyO<R4eQ&(Ow`=hlmnmM9j+US?z!`N%BgD9-E
z88P#3eR$qCwb|V+#a4tF=WPVC$vbFIwiIjCotME4<lt^WVLPX1C@WtfH9_1eAP=I`
zW;`OkFc;!JOkPGJZr(_F5r7D$5D%p;r5Jl9f7Fs%oU0KQ^%QJGRW@Q4--fg?<Z#N~
zO0SJ;Zm!(bs_20;rdhOS8mM|l+2ycbk=4B;UY_OaU}6N*%f_(PXRlV|w$pS?_AJIo
z;vyZ^<bR74vDFY~O}dhJ{z5mpsNMf`%z&>u6qi}p_qE~0o-Rd^1@NLzm!rs*3JrSx
zPL$amoKXt`mv7nX2-d&Z`fg@rX<2`CcvEA{T3u*QzYw)G!taar2jdX{g0rzpsTInD
z`Rx*yehaR2cFLXf<}}Lu=@|R?h9in1JZ_M*Q)QzirDWavO32EzR<B>tqDz2%mj)LP
zDc4R<*FuRFuU9G>1)MKwH*0F=a%ttaJHfZ#YJcGJeEcALVUU<BSw<Z_y(1SKq4~gr
z{0P5#@8=GFr;fs&fk8+XbC&sAOzg4OvO0Mj@XHftn_$rFcOuq!2JZFzu<D=FR%s!g
zyhNzUo;{loLh+6_{J3PUck71-ep^wUzo_FCZ~D;y)LEFO3P4alS-j<o?<4tAEXK66
zO`gr%JKBrL?;Wu3*EwtD&&XRutN!4?t5w6#E!eT-z1L9WW|Z-k+p}}D#d$!WE4?2r
z;OEM&K0dk^(%t?$f1GMVv;&#zr&I_NodQPg_>Bo^*PV-1Uq0(r&g{P4MWfulb}Cd3
z(w^KW(SO;x|3$fr1J%L)mwkKosTn}}$H|5NF>?0*Yv1ZLp+U)$nTD_dsj62Fs6WvK
zz*B(c*3Rk;%QE)1p;h!R7zm>wMsjiy)++WUZ?>>#TFqM|!^B70a(+KPP4VRYK!_&1
zpej&hDz4)@J+FD5w_PnQ0AFuU;KDfZ_T-7pd&HK;41w94%Z-Tx7GRU3z2>HH?e=1c
z?G5&Oh@u~vL~n0AqU?r%Rnv$iGgW5#rB9`vYXU;($1oxYbmxnv!C-+pzh)vR)2=H|
zm<{E7E2XQmHt5!!T^-sVC+gU+>Tq7|bP=jmvP<_mQC#4Aj~F*@A@>Hq1F)sGH~Do7
zh8i|eeZuG8RXC`a4a4B^UPV3yz6W}htQ<KjP4*bUv6mlQebeax7Pr5ZBS}0F69>0b
z1(uMR{MiD|(P?pM5LL8Fa8G`lXxZ6r(RfV#cI+0>?l>ucj-R<>a>}wzND6HVe)lrs
z<!`x-D0~5gk0-nq+rVn&^0A2eWMJPm99<!H>EN@HPxn$w%Ly2*POMN->%1CQt8n9)
zc(De*#8;l3VMqP}G%X)jRiRU%H2N9$k0#{Kne<!Kd795;XchO52EG<WWaySiHjDAa
z)Ath7+Yyo7hvq=fw~U4l#&<|nvylz}F`8J+5(ua?X>1xUJ;io98`0=HoL6{%?$a^i
z4}bBiUoVJtURK}-(&*u(`^s>#E)QAQj>kZoGK}gDJ{qsnohJam)5p6GDU=5&Ry$-c
z&qf^olM$HtOzkB7`)~wcl2K5&0lKQX>gZpb(%dBY6TR$Gx+Se4x++Xk6fLyq<QQNS
z(4_|FBsrAfVXph*(x8ryZ#stfmgm8ah%?+Xi|Ne2WBi{bD|Zw~50@v*nx58e{e7=m
z`&(BOzTV#Bg+O~E9Q{v$B|$Vq=geor?s9Y)cY|cHj;{qq8VaN;-G#gM07zHZV}Glm
z5-epNMyW<>pgfTpy|h;i%A{903Y}K!e%j_?8J4Z!=4iJ{4;Ano_3bCw^{yynR*-vO
z+p3P8x6jwi{`?Rr@UPq<W~^)Wx<5n8{FE5=@oHEmG#tCUw#De2oTa#|xqILn%rJY7
zEm+;aK-4eaiS>e3?-}MtfR%@>etUZBV+v!iwlhO((OOszR;&Y+wHZX%2|XW*%<8&?
z43hnZ4sY#7;i|*vTsx+HG}_o7w&pD9_G$EWv@X>%3~nOo5?if89J11IDA<J>(-M&f
zove$VuyNDV^|W98@OUf>+U2{Xa?Fi0WB@Z`AF8@?f??J(*R2Il0FG2M+8V=_+XRn}
z*3RMqqO$v_cwk)8Cs~|>Z5&0iP^#dBwu8K=_c~at_y}Wjnw$pVa5^K;;~DBR3!d>A
z^?@(fC(%jq5hztvw4QzE=r05oGGiNsWs8_IOIQE>jJ}N2)&rlwh`e$&e(Ln9jtDFW
zo%rX>C06O{QsO!j0Jz?cax_d}UAdZ$L{BwoU<s_~s6)N7OW^gvNP1J5sofdHOx=X4
zyhZF{m;;<%Mw|WQ^_If9h2z9L=jnw&o$ihPv5Pv8@>)7kr4dq<(yUVIfDE!N3LYO)
z8{@gKdUX_$N#Z!7pdd&egXjPaBY&R_BmW>Uis`mAs9wzv5bFr>LvdRLj3G5$OPHZF
z*4_cVo^IoV^FqlR)a+u?6*h;*BlRg&%xj;9jx2cGP0mCTZ0XsgU_y<YLobl2ZKL_t
zV2n1yiw|r`nDmFOnUaaN!uoRCWwzhf<K<Vz_3wl9ZLh4uVJ(Y<diln)wP^F(q_Kk9
zb=m^*RynmDfH8D?CeehdkdL_zEt;j!oq1dCRMj5&YuFNLdTX`fnS}_L)&%rBZ?gU@
z`ikcdQVwkwio;08Po#IrOpesvA9^#k#7?E7_h^tK58SgvtiRHueTc^3a+U^X>l2W`
zk0^9R@F68<cLhgoyrqQ9{kKmgf2lBlF#q})hk!lA3{cji?+ebB+HDtIti2lM;K~So
zm-GrFBpMPG{rn(F;gEQe2$yuR+Ffafa^GaY=zkw4^eGNkT0xu>`&-#|jIV=T#1Y<>
z=-(oQGgEi~k_$GM2%dxK6>_201u?o6;E8Ct{=wrWG;}+6*op5mDiDCwn*WFA@cB^R
z@=RcW2Y{vV{KbRq1CRB3Dwz-o<;)}W#uDbtK2L^3B+hrF?d6O(eb|@^|2A$&q<wK>
z8PNj46Q_(v#bAuu9EGylB1l|}g!2gXW&8?RzpEK@EUjnKBIt&SamZ-=7uhp&UDOS2
zP147{Co27xm1fB)m`?JHqO~Q?`R~4^-k>dgC=1b!>k6|hvogKHpl9lOs~@Og`ICf!
z?}Oog?pnFk*e{F!tQjX#avTJ1^3BMPWVumjK<+=ghpveep!mc(Y4HnL$4S>}PGXfF
z0j^L9CJ+|JUNl`8PXxl$y@}862PNCZC4G9;V_18eO|?d;O|M$CXJrxvy8T7%`djq(
zul_g9mx>#%=IkxIH0WdRryQOgzw~Fn9ljkN@AsYhz8^+-Uv2QZw;k|ADSM)<*sOBn
zfCNR-=%62Lkq`<t)Rc*0KQR~X%_y8?ju%K9%`*}Q69?r@P)o@L;h6%Pr2G=qP`Sw{
zEt9#!A4t86(1->l#rI5`{F=~+#;ADjr2S;V6seqkj^s=4H^1ni=BFDazleY-Qrx!i
z3z7|E0l#FWMZTKCEIIhg_vm2tE#bSz03Huv{zJ3^R%>NLQJXXeF^R34H8q}eZcz$@
zwC}@d<qchZ_cfJKj-4|dma}*~W%&dEyAX+LF@_sns#+5uo0wuD*NG3%ZjKGMEmPnE
zr!?uzoNCCsLOb=Ta+%q5LE<|u*EAI;^qM)to*Q_Hjgdo&u>aMfe!W)JP^X^)Kq<e(
zYh&;UPBVS=#b7K+SJBG|@u+??aP(1)R(>W_jX>;#wD32dahaN%m`XV#;3z9W+~T2`
zWEpNY(?^pqPlr|dBZ(i5VppukNz-W?IsMn}ps(0%RK&g1SN9_OucgexQapOeZvu_@
zA^SqoW=Bg&zvONwfqxm|o`o_jKoygxT(c6P$1HD~Ejs!l3~Py94tuyRPSLvqjb$E-
zeN%*2cUI0x1s$}&$|J@y{pRzlivJCsj@%C{2eW!3J|{-UG;#~=Va?9aH;3RFqC8&n
zV~Y7Emg-aN0ATToe>6tce!}2u)JbMsK7q*>gj9EfsRM8_+gRqW&T@MM02j`8V0^<N
z^GML_ZGll2xZ=hiUw?r;;E?-SYB=VBb3Kemz~|f__iU6N_tP)9FH7|7g_2NBYeS~^
z6JwGwBQGx6>*rYet-XeGw6D&Xr<p(mmb)L;&cdBPP5^OJ`aj4iG=Im+NHfxw0zbQQ
zXX^cl_K~7|@mTVJuzzO>zzwK7z<Mc-Gu&$m({%g5?VodoZ04=%s4`X<<LIf{>x$cn
z%HIiGG!U>`FJn@WqNQAZoLShi_0k{4;|+)xvU(|w6WW`d+U<A<QKyY$jBFV6tbC#T
zDmtk5k{#RFzyD<yu%$vzRjp%N*$^;pf@(Hwmd6k4xyg+<cr360xCM`*yR_MmSm*pD
zZfHQxKw#uO_ctCJjE+2E^s$1)v~9k9?tG+uxW1NYtE`+Jb?N2jaL7#<X{hh~m5+|C
z>v_w>@Z&tB)2sJbtxJR}h4XbbZMO%ID<1oc9nJLc!6H-Ni|*a&I_=#y+n(LU-4f3-
zwy#)v7U!9sbLj67;AwNihZP7nB-0$|kzHVKILf=;Mx{B!fEnDvNG)0$POl!eh>*)N
z);4**xn0*VhMVvXdB0mLN?2)W_lzJ|Dj|Uu`a0IFtJ2lL9z^%^DXCFXpYVfW1a)H3
z*ztR(K{o~~AC(SM2799_SDv4DzV~Xj<{GHtVzEvgpLKEyAU%grB{=p6YrfGia*5A&
zXo3sbk$<>bb))9es^Y50`{M!KBIyXG!{+L6EL#t?N(1Wgy`x!dq4~Vyf?J9c*6Y5=
zPe*FE>(4Q{F{3fk-F4Ui!R=T-&CeQ~S#H7nunTXISJTra`GPk>sB?3)fZ`^6(8JQ~
zjY;czL(j_!@NbSVQ<>8iW2;=HH_24<!@QePx2jia21jy=Ss;x0Hi+}N?Lm2GhVKl%
zlPbdO_2duD@X};5l-&0^hUKl&@*o&L(451m`%9bVS--0UoT%>kRKl$^SrV_=(G!0b
zuPGFcWcF+HL2TDYWau{hh1nZoWrnme$FnKebxo=OV8XGS_R9&hqSXPe!`ummdoHSV
ztE!z=?<3NxJ6pcE<aQ{E*BkpoR9c;0)kX5w@N5bo_Z+?QBg+Eo_Hv`J;soyhGKO*`
zU`Mn=bcX*_alWPyQ-w>3nk}^4p9dJ!d&jBYUDH+%d41d+m0@yOXN6mhD0@0~#I(HC
z@(}+4$Puu4b|iY^M?gB8x~@*??eHZ==_9U^EcxTx@;s5rD_oK0yO_<Bd#e$LmyH*l
z91=<(>Kmu-lmK@ciM|Jrze0^$385A#4P;oov=H_Rs&-M_LBkgxu+^FN8+>5mf7E1-
zu)cYNAh9T<q-EbR=kLEzX|o3fn<09u9;oR61R^D0G>laU$g@NbHGf`>QD+hwAGSMX
z$i=aa()!$#Uzu_kgx!o{?@?1I%ZzqEB^Hi}g#9o~Y~V_(EV{Wz{TsJbFx9=sjdI$L
zG#2~{u}##IJpz>hdkatp&a%I}GyUf&c;lm!e)CVeFTsF-F#OB!C8t23CG!Ju0kIm|
zo(metU+9x*WMY_>piolqBqK8>sxsEnR<Io~5IMr8&>V&6z&;O%rj!X*@-3{cXQbQp
z^u9E#>@-!Mw{^grkO-e<6RM+AR*q}>T7M=V+4twivn7bZpdzb?m+q+Xl&n^Q)6Y?2
z#tE$v3Y_%B{mCSFqBL{8LG`{K0NMy_c}Z{w<z80^4bGNUs*~tw_iw3=PN+|<WGA|a
z=Z?+|Kks}d&mbl98ZtT(EQo`#o)}STsa0fT?qZxQ0jdG4*jiZRWQ#bMQw8fEx{O#W
zneOuXE0L%&ncC`x>I|_vwqkSJe`LT+XclP6Vbih}wD$u`9UNHcoVVGp07>%c6zXjA
zZ8mFDSs1%acg4So=UNx_AN#WYs23+lZKPSCTj)nwP-3#@PV?SXXaw^AZAHN(?q+1l
z5|1jaR@N3SpX@EsLHA!~w`((}a&J|W$+U?>VY#%yo>I^=lwNA=a7irkkOK3$@Z%%D
z&U#4C=rulufM0^qqOWhR0pvP)lk==*bX>_Zd4En@%*stUPd?~sw^`ekDJK;u)7)nz
z%2t|_bq~@*O*ysDC{F(d_8hB8w$>Dz8P$f?vjt-h75zetMRZxG|2J#bDs%&bafX4K
zJ4hLljTr6SAb}TDMnG~<e>1s&j(RA;h<0@Z3YNYP9~86&BgNSeFbHmk!t5jA+-~FC
z8^#?l*!iG^Zg(IWl~<l;#9^*DDEXo#Jj?hx@upuD5~7Ii7d2ZEXMmg3rESs!4J$ZS
zf#t#=v<TDHHZ%M#GMN4%GbrjO|7)wGthb}=0Ii*xE-l0n-7os)6ywszfCjHk!;CK#
zojIR<(udI`!$Yhb@NCo^(K|@W*cM^Q=5n?vBgV$>qEO6gbz$y6!YZhN8&CH_D0KTL
z0G;_u$Tu#_lB=OB;-k&mKh!{2kzHd4D!MtALa#=;Oov>Roac`k#0|<{tc=`k#<iN&
zRp-1=3xsn0On>#(jGx0K#|Tif3vewjAr*8ltq9STi}AkA0P|?P`|D2x2Yp(kzL86_
z>`rEM|Hy8I+?m!vW=#8B83qvBKRw#cZLu>t(F&L5Xy)J1UhLBx2Yuf0+qY*vTn=RH
z9hHeDwd7TvY0u%m=E`^$e$*r*`;_I(Qkk<av)Yk^_1E0PY-xq%(rhotk>wWIsEQ^4
z13hT^q=g^K0OBI@!W)Op2!9A>?PKfbEnk`a^I!9k!1BFY2upQ?JOVww#W03UdEJa+
zmVb$E#+$a#)`5(ol;#q$Qc6Y92~qJxK7EX+VGv9z?oCDjgr{E0=x#NUrGx_2el|qS
z;M~C+HfRmzHDIgIuJRoqy^HFTZ{^-S7E<Z|ypbcu2OvkFPP|Z_ZF`c@e}#TY>fLa`
zLwj99%og*7Dd>d%eg_3}K~DaABot|^Hvp}HGH4Gr88KYke=4CBotIC^azs2~it8+b
zIzS*JnqwDF8hP+nSAyJ@>hxP(WZFJ&#FpH>Dh)3EnfGp+I7%vI!7Q|oxHUy%-1OJe
zq#{d3CIJ4b+5`Z(S6XT5+NZkz%j?uKMh+o@%IgO$HY`EK?k*X`(3c@m)DYA6*8_Su
zYoRd{k|MK;_~C5s5PXtu-Y;m-EJ~@dGruTe=L*+D&LF}Z66OFmlxO)O_kwixogr<o
zRmD^xNvg!~_T;2V1=1Hj?wc3sFR1_C9-;o#n*LWcXfiG6`v1aa&AgbA|C^g_z3tFo
zBY=Qx<A8vW{5Lm41mtSL_@S@(f917wv*G?A!9=ECZCD+JCZIc5#oup8OfYI>Y>_e>
zT#eBnv%a&j6kvn<?J(a}w}5ZIMQM%KZ9mUxO>kmmzhaPxJmzqb@ZML?DZhVg<@#4}
zp7M2jV~KD+>{!!ir{@6BdjpsPy!?sZ`7{9G1EvIW=h+Nt13p6W^U{XdeuM|bL4v2>
zG9uh?792DMKJRLS-vC`*ybR_)O7XuYgsHxChT(9xEsZ$pu&oB)5&j{&lrf^D;c$1q
zkpam&79PLN0jgVR@cg0jquWeMo7bASS)3RCzJk4I-aa$pC?=@FFL+6JKj47o9oLU9
zOv8o5r0D)+fJh&sXJ6eO-h7DT#GW|MM=yRKMY!YS9-qrg9s2>1+edLAiJ#)wv-^ke
zFcQKgP?h&fTJT#t=_5Mlvl`-P2OfX4|KbG+{5$e{{%!|1fV}-na_sy3r7=v?>Lrqd
zID`?GTAkg7v>>v8QKah+d*MaV_<*zVsYxiK+yn+4z&g@u8Az+&a%$4bIMk(89NpTb
zMFrVnW712>X+=s30?L**z3yN*de6Us1|8ou1AG<r1}x9KouwS{)d@eGuKrGJ{1V&0
z?kheR_WYC8F)$%Wb@8gPoZrCe-K{J_-B9G|XH)>VycYXV6KZd3hYn$#nTnC8$^Jp$
zS>`(mXf0#)c!pe=II?T^RU)`X`_n<#c5Ii$>@~yd=x$kaDd#!lxv+*qh{vDTpwDz=
zM&knD&3;0H{oAH5e(b_B>FFT{4e^#kQ>D+5F|$7W+9|yuU@UKuLZUD+A*bb_Qzx4Z
z3gDE_sjDr2X>cXUcCMjW_m!U*S17l<uj@qzD7goZa#m{R)3QL@S<~UBw|-vVHF}LN
zwk!xF%&bnxO=o4f*vEHe+e$~irChz9*-3l2GB7n>^k+1=-X}~kMDreK?|3w8gpD3<
zO`%o>o7v9zw)t9(GJ0n;C?1!Wmr~&=JkRIZ1vpHlwbf5_&cv|S&W_6##>AVZoFDoF
z0+*Xu$h?KppCh~Nr<Hwvfy}KUaOmKuX!B7pP>73Wom@<O+}Uw-A8Ri>b!20%_CRzJ
z$j<FO&S$Mk=|&jUAC;=g_BIwXzD(LDIWVgnaS%|GL|K*-9M6>;t#vz`&6cULZ>|0-
zzdeWan2fo?%G@N`$ajx88Kvc2$(vCE=z8A8{4J}Ez_M=LpRbkAP8@eNOA<`+ZIA2t
zOv{#*t#VgaJ8IA(-_#e!PGTXYx~S$>%fwcLI@F%NlsaNdbBs?n?x^eIvbm`-nyfNg
zaZT|WboNelisi=e0<+yXmtj8K4#~|;I<gjbR;ER)rjtw!+VcXg&mVd%WruG97U@GN
za(c3x%-b4j7$}|PCRm)Aj^)jmElJ_V#1s&*SQJMr{DrV4$1l^KY)q1A>ITWc8mra9
z@Y2#XtB_Z0OqyxhA}T1`vi5nMdubeyH{|$#y~}@4227%JMP1R;MtA<HMxD#6nxQ#X
zao^S?lE$!iSuKq8P<4w?K&u}EIA(j%5uQAjzUsp|%DZKfQg+EZC$CmUX3O89I!9AF
zZ~z$_H_&}c<m)kgVZ3!HyRv6rpHe7&<Qf$(v9wfYmJ(g;V8k$)h<g8-FWS)z_DDO@
zvPkeUZfb{xk*hLpav%9Qs;BJzhLN?JI4ae@2hOVSzxN`zZK67I2$F{Z1o+gBe@1j~
zsla}o5zeBEnrQ77CWnuP9Slnr9S|N+`TQM;oU5pUm|IstcAwdBSe%%bnN?`?lB8QB
ze9S#Hx%yYi<s;U~&71m!oto?|jTRkeVYduAeq5SKG3TdkOgg%obdJyEZ&-O-V~D%n
z`|2iPu3ur5CuTk}f_EDMppiIYh>vDbB_DyoL>$K}UYD!UOeK_$$u<$mDUqb(2wn1)
ze#_b~CDn#avw6asz@G+YxeU>)tEs5#YqL8~pqB%4L%csmgjWbvb5J~&{xCGvRjN8b
z6uCT`T<+^pa%Rpb01<Wjj%H8nmUVcAdqp%(s0Wy`mM1;4CzVzKS}2^OT=G6MbxGb9
zEK}sW?tTa2OeLRd)h~iq;>~eHkN2H9qIhLRo7tA;5ro;;Duq5=wrVW(rlmb;nZwUA
zSI1VBMbbOD9HA7ha;X)ouPTGAvehaiI_i2e>K^Q4(HIxSgWA(=r83K9_6E<KOzUma
z8|7bD6<Jv(DkV|?msHjf6_pcq1D?Jo8xA|FP)#ax6Tu5ztZF@F0;q>P$7ar2BdMk*
z<v5}GZB$M5g6)=Ca{}3Q<>BVf;is0=*;~lQ%JWcF(Q>nlC5psXs@ev<dGr;AXvcJ!
zX7sFXOWG@+DsevG%M-y9h<ZxumzDd*Jtf1uM*mLbs>(jVG7Tlh&QP7L(K#|I%c7$7
z3x+JoC}!>XcnwtJcFUmry<+Es6D_f7CW@jGHfcT0RzBDM$+_+vG}yk}*K@>H4`9;f
z)shsdCeqhY=U<BDNfThc9<8~Ju#~$~Q3EkKU9nykpw9SPz5XUC?lp4<#;sG&qVm4X
z=D1ILQeFyR)J)S|7RysoakK(btF1e`#eNc${e)wLYaBUN3L5(XzaKz*;MIggav8Z;
z!=S2n@KJH_3S6VMjfd^?vbKMn^2}{M@YcornJEok$H7+qR=hcTbaupd_f3@DBOOto
zh2sdbT$-kOEVnYd^qywm-bC<s(h=8N@iDC^-*yNfW`9jLYO9V#%jSTi-T6~r^ZD25
zB(17S^VK)AhjQcJRg(pOUxK`aNw2C>dfNl8j~cf9?3p~zYh$C!+Tfcr-h>s~4~m4|
zhrW*z$68O(SICus$5mqsUM#f?*?Pl;Wls*GiHaIO$dEDu&zbvly+TA4_d2DbA&ney
zd@xKv&}xMBl#?J_0jPD|ta|OuPc4troN)8xx;&moJJRW1CmtWY*Aj%=&O(3CqTT}>
z_7+dU;L)c#OXOXRTWN~vlMWP;xNPa(P}U-=G7eiOg5?9BL+^Qml;DSsg0E+*;CZG+
zIh{WR7V}{eGq0UWO-8?LrCT}iyCAM$vzSByicyg4`a#Nb+j6wK5~r&QwR|ZO&A&D0
zshx<fsajKb6l|pXtD1jdKxR;F@bO|bxKws1L|yFjmyL)=(;var3^DDR%K&M6@cX4^
z4EOm5a*bz*wA3gA#4KwL$D=Q+e1izm|L6@=<^3^lA!jmmPl_6b(_+Ji!Dwis`m>D!
zfT1@cXtckYBMrQLi_jPdlPdTnrRendl=gfo;IrUBh8lAUX(xAWW8;M;!Dy@sy22mi
zuDG{;dkog5C&7-h-Sz7t&z57EL%{5cQzy2yBcSf=(Xr&Rd=7bAV<47lsjPS7H0m_=
zA`5o)YgLg@v)mr?G6JGrI35Dd>ZWT5U<gVOzxPJi{MAW0OLpw4ct8L1gT`Pt)Nlaf
zkzVA@WfanhO|w101j~49+G;J>epR->*Q+TW@LY@qg+1JEjNE>Jjz|K`_5CA>^%w0L
zv<Fr4RtFzg%q<}x`r<nD$u4orh(FehT|7$Sm*bniw~f{LtbXmEOqk9%WeoWU=mYJK
zfx@ZfTBtKL?y+9<{DHKG;r0w6aaTQ+OnELOu3sNSqOa-k7HwYMujS$c-WRBOzyTj;
z??u=jW@rfwamVrTgYdW+6}9VwngO^&Ks))XHhnJBj;TP_DdKKrdPn}_>hR_mvga_8
z)sF<|q^WM?NCD4u;HnI~kQ!$KEG9*9sdUP91YZ%rb(nWtd_wc%^tA?e!LB}1M>%ZD
zb9sb4>y2(7g82-+!>;aZxBde6!*oh;)*O$R4uQ!iA)paq6(=swTxXk#VkhvZqXi<R
z4f1OJxF8M)A7D@LMGDX?eJNT}zP?wj&A8kLY5mQ5&wK;W1#L%i4@1HL{K31n^}`H@
zJ0-e?NBaGk2(mIh%E6tr>!4U5n?P(Z(3odLjtq0po@aLny`wxp3==01Ur6<vmsDFa
zy+H!3h|pVcmo<)R*pw9yZFWv7w~<{!h|=l}oEGTsZjM8Q<?TaMz4Cc_oa*a!#v&13
z!Y{cFrPd?xuOK!#Z$~%^AbIBtQJCF&_sj$5WC{Ky%yWfr%y2CrCD{)H_^ln}eJ7bS
z4))gxXFD7t#m|w&<Qv;jqw)96i^`UtdZo(^e7?~ZK5V=z{&i0f!_=}oMSSzemE#$W
zQBn2j9Thea6&=e;Q~@fw$**kqyH@xcg&!Wk6~4*QOSQS*E7-glfV8HZY`KUrnWK+d
zuO74IbQ)EO`OI5c>pw=^l`(u2v2gjvt7y<WG(>~9IIqy5H#T#rzSs@1k!HW*g-NBE
zsFDh$m=hOC3&m7!q{wwea`9X0MkqEvN0J)+8K!**4gtF%nZzhROjB0vEqBMO@fmQ{
zx@4fK?l?oMrQ`ec#q}wsV*JCqWFW%t6lTCuoIn7h+6gWmjj%k2cEZXJ$#TfA681(z
zIgmPTZ>RKj*g}y138jA66J-%3(-AWOVEojMT7{_CGWjy~h#^F<mr)|kkoa(s5u_7V
zkrNuQk?$y7ll3wwwmU^pFEofWbgm?}?12O}))=V}u~GJ0t!*0BwXLmf%TKLOy?v!O
z|Dxx+)6;@gnh}h$-|u<bk>}z&=f=;_;PpLu7I_Zri&^;dGFc*Vlu161JrKap{yJZA
z&%-Ee&Tp^>L%83bhoJNe&djceJrp!=B)OCZ_7<HH@lP$kdRD>E0vLN{`Q!%<?Cjr%
z8j#uJgrRasE8JO_+cSPmADI#!(LHa_tmy-Ay$N&BssoqTnuIcytSY~{W8Bb_ckjR<
zIP=jWkm&>9eE-O->`|xOhyXx!bOu(5W#!GglV9`jZmoxP;N-Rwv}cK?hgNuU0M7Jr
zo?U8z8eIb}^x>mN!Y2z|&~R_|rE_i8wzQZ+_~f3~dKu~kY`eh8_Sf>Qmyl!138i%v
zSWjj<wO`?oJ*)M<$9HWYt+(Q^jz~(?xAuF{pFN_2jEQA3#tg#tn}9ke$zN^G-TA`-
z%b%Mx_Z~;iTzExGr2*SCvk}l}>fD$G3R<Z0{Q15wtk!a&XrSxkvGZE2ES0y6p}ydY
zWUdFBRB&(NbCcj7+I=E|^$G2CKq^gYKMXXMO8LeNhh@nYF%d;(NIYE46?>cQj^e^f
z_k*x9^=wYgTHCe8K7hjkZrRYWY^%PGyjZmRQj1O*%7xAhdz~Pmtd`EydX0F}pCcPe
zL-OsV(rmef>;nr;`Si+AG9UT+%E!N_7V^yk5vgBJJzSWPw#H@J4rtl9DhETQlFeNg
z#3n5Qq$wvI3|jdDP|;;){sf6;L#w6roTNVblHqw$HA^O03;^9&ywK4DMi8DISTYMO
zx=cpKPl#SY?PRoQ{kF_;T_U6lIkc?UjP0bDwu@s4gy8)^uW-z@n#?f2a^7BzcF@^r
zrz85lNHJpng5gCDSx076%mwW_Ts!AHC#&+gRCbQZh_SSE9tEy_4ihwIamgoc)ivql
zAPM6JuGps%KY$}EncM-vJ<C?rT1z2}YE)Bsi-#>-I=#KTL?)$#*kf4D&(Qjxo)4!E
zWk9Ny`%RYW0d15Sgs@B$8!gKvi@v4PM8{QB?m1sGZIQj%K?dwgDG8%(`oNQvxDu6P
zOo2Ry-uOs_501g)T+Y`VY7vt%Hi1G<a{1x&dTls*FhB%?M0#F>nRz*PFZFOS&2n;!
zu;xk;wt2?jO5Wuqdc}#IZm5;*P53j1tmy=}sw7xhrD=(dc|BMxj((Rq7M$a<d~vhT
zh6digvys&o_2+06*AHIcTA%$NG=j3ZgN`XYPPq!z-I@WflCrgi#~fDF`%eMu)o_Vv
zeU_vR8Gv^8WTF6u|Kpa=*i6Wah4h)0wPFPVm}(@i!7qeXM7m0GJH-=<ed%V=_Pd<=
z=f_imG{QE?4-_aBC5A)9a69$hEbAHZ1Uo!?E=RF=W8yL4<P{q?AUmD)xv4&LR#~)k
z8KqlwBT_-rNYsTpn+-WCm|4iYl}&c2IcYG;UjX0gpJ6;VhRef|5R5pgT6kpp<>~_q
zwPt$XAg&<%AG`urzsIyC^c_bjy6a?cQNmH5*t6I@f?`g|ocb8i{3h9m8#LL01M_lE
z121c;U<#yKXz@Wa+$Y6?gt0a(Vwq7G&aU>O)e<JrD8qdawF0H)x`jskb4BA5Jq?6&
z6aYXLW7?1yMPkb{-0x^6fFu_>o4c^@Jm<;)5?tY?*`*73)T~Ersh#BEIm_hb?8{Ia
zTiP-)6~{ybISn^yGB~-@yx6k&Bb;q^DOb&;LIJeCsK?hn{X}e|ncA$G{n5SKJ{{qt
z0OTAD!Cl^04gQFl{&`mRW~ocV4_j|Lc7QjjN#`#MUAOCx*N4n3{q~x_Umg>c)a8zS
z>~JO8+*3Az4K6zb3pIMr-Ezvwlr2iowcPF^YvPJo%SC7lyv7dF3p(^IRSKcY%X>gs
zvpYzt#uv2*8-<-BV@BD~$$M1~Pmh)oX$C%XdvoXN+!=zA>Pqh=R{7GCQ}5L6a)4nq
zyKpe=XG}odyz0MyF<0h=D%=qK6-vX;P*R_6TaEl=Fv{q`VrLf~X|KvI(6?*v-9Nlj
z>rVt=0Y3%%D((^diYE;B@frn)3@ba~LRQn&zhD6vv}U#uRu1~AnxUlPd-at)>HTpP
zGkFOZ)x;vRbbiSbTn`MiI}`1degM9Ina+I!Hfq1}iJe`?DnG0n)mMi;$t+*>K1KEp
z!y~9u`%AFlXfAToG?XQ_wXCzG2fI*_wNMc&18EZjYWx+nLaj~M!jBeqGR%3C&kPHb
z=2%&<YDA7QkL?5uBzMy2@V|m~^NC-7f~I=DY!<PHKUP`|qa0F+4nIvAzyY*?=w}vt
zp*m!mZJ36L@S=PLuvDUb$Lf~&YmHZ8faKB55bdUYy0%1kuB+(XOhPt%E-pU0U@f@@
zsx7#L{)t%Ymr{G1EK=)*551Z79N}7nXm8k(zCLO*oC_OnQx^wZEMeA(j>9b6V}>(*
z%bRF}TmP*~f<~%{j=K%M4IsS43IPWOdkmdmFQb7T#+p)0)||~~#3EgX@SOc%E&;P?
z%1q?)2wiEZNQ=6A9=@=w3L%wT#^kI8JIO^UEay4~$fwe(UwcKJ0JF3Pxt;-<N`%QS
zSaeSkptd)r7NCa@$bf24M=GD@U08gh@T}sOa;)|X$ya)n_QngE1)P=#9SV1&$ch&X
zoX}j(jL|ts3^3~Zo_M%P9#D($Po~i;zglmTspToZQVUhzKC6B8{c7~Gt0|=p({YD`
zmR)fv%-b_zT*TqB6-D(IQhMP@%|8J@s~}JX?oHh^De{@p_75;csWC}E+(W~eSMjGB
z?g>y+j}W2C)|ZvX0&14k0_4l4-wuOfD|-a<VnVKz6mx`s+AUp>b)_NagdU>Pv%r*-
z?Z+tK1^4PqC0WUt#O*R+uw-W?K&N;W@rJD{91-1Lz<x^|5k271euwOgXw|F!sQSSC
zRy%5cC0Hz|YmJxbKgp;0a82F8aQg__k=6B)i!Hln+B5x11sGY5T3OcMDfh@vD~zv+
z{+~L&0xHVp`+o(Nk`R#Y?nVRwk&sSBMCn**q(#C-RFGU@1*D|AQ$RvmVrh_WkOrmu
z_rUwUUs(PB=bY!9nKPez@8{lUW}Z2_Gk3;suZere=Tw%K^Z0dJ?X>lyQ|?LMG52GM
zYo*UC<)vxBll2cJnbRe#zw)-5XN0H9aobvj{j7pl-MBaKo^e6p5S$80evXzF68+Jo
z`Lo`#dlp`tf?yhTx+CiE%se7&d4Jn@DuHF($4S>Z+Q+z{tEc^tE`{v4636wOPwL8X
zkYzo57U7~oQdg$XU#8lsz-=B(YKN9-n>-EsLsmVrsc$$twkIak-O$(Vbycfqx9Q<}
zy`;SaG{$vvWse}L-E6}|gIw&;?&)v+q-y?C+}v==Fn>ltxR>&$=S@Fw3?pua3s=k_
z{AQIR2W(rQuQv(B+Ls*NEl-9HqK?AbW>=Pl$DcR#IR?=_nUG;;>>*n#w7<LUGGaM=
zw=pQO#x}=8Z-?CxuCmTd)I86Zh`~c?8Wi-^>ky()=dY>NyE><^7Ml{cm~XA#$f&3s
z=|)kZxSK5CO)D|PP}Fs{LXX&d;u@xWyQ7EEkf7o*wD$;Sv>~MB7bLw#ydsj|-sle+
zh$)ZW?_gP(N~1TJPsuvPPa601jWj`V%cVNvz7Ke2*lwlv&!d0qjJ#KEsVgx0p@Ec^
zsKvRhIfb00%-~4J>A|L=VF4P<!zO&oRnG|GXQGWmY!1l|-3xp;j=z^QkTRXve=BtR
zkeMoG4f-{KIQ?x0|81o(UO`gfFp0r*rAKLkYHdvIeIiaM3J<=FY1mpJj{O*|jVj_$
zqi3rXV%dazUz&9}%qJ%JbRP}6(6GivuYN6jJNxPfXOfX+8J3(u>&*&0x|GV&#*y;O
z+j84%0)ikoZQoH&|IbBSL84;pjzvAEgCw!I>>=n>0cFcrf4|wNQ6qQ%uT6pB;0Ud6
zq2*+^zK}-gr}t&Vx4mbJ^l=93E2=!6=Jd-;lNQyTt=7OB*(H)UJM!NW_zdTJf$w!~
zjr5lbE}Pr0Slzn{FXv@$T5xv6EAZlmxqoU7e@w-aTJ@Xnpe-A(Z(l~(kFr~hk#<B>
zhdikj>U_uSlX7te+H>>nU^4a>7QK;+?XtTu-y3&h6v9nw{q<<JU%jgdpb1^T1S`}z
zL7G6SI)P~ksmBf!ut@*XiG&y4*w#+-{F#G(rw&q+H&pF7@eh3}!igWf(Gt4%@N?>n
zyj<%Obn14g3c@1o9_K9Ixh-4KA0lG{j(I8hJx~LMkILpfKbBZDu)0ku$#-{*Y(>YV
zzsM9Xb#LKS5*06W;~b(-cy6oa?3&E$>%7^@O2)sP$m<=tf}Kv2I5k2aJ*dsE(5EY|
zTupR+ksWGl7kb;A7LkFyfY%+AI>E4^-*WnZykqC4RBO}`%u7e~Ua?i;{A!sL_5jD{
z)Ke$}w0p0kS_sNOef==tI56*ybo#&ocnjSkWY4Y*p98#wvAE4Gb-!}KZg}nINs9qK
z2db8UO~il@!P>hUUxQh?weOiy>bVgh($<7vJidvp-BJB`PH&gQdo592dYSw0qr3D$
zoY@o7Q7tq_-^OWd66Vxk$h9SJSz?VV?}b7QKX!iFxl>6iC*5c?fVxeW^6B1J3rTA4
zC)e4fChM_zEo2wz4~07_3H9)SN&8dj5YLO$u1$EeVOs&4Pu*BHVekRo*M%}I2`O_v
zPa&803#G&n?(u0w!s?I}0+dS55R($ZOfy5Pa;xovpIBL)i8sB)pMV5<Sm=tu-Rme&
zPxnk3VKQ`gWw|~QN-~>TYM=X#1&+89O0d@xvx|>xITgB$x6M|7O#*w|XJ7DJYtw=2
zT80Lq3b#rpIHXRF#ViOwg+|KL(oH1QNu`Luko&o|6_0XlYZ4x7Wg@&jl3f2B;RfsO
zo&FSODmJggR~7x600t)rm6Dx}x^b!peLo3WowR82#`oed`K5#z22*gWHvqpDuoCWt
zyLN`&u7if02%EJimOW6HBA3s+z4=imn=%RV?ROO6nEAL`;AVzxru(zZAH_mnFnjEI
z-(>|jk`5mF)LeV|N-Q&6YLcjg!LMw!6C5^~PqmBSikVW?Sb4U;K*Eu#OECCF3Oc2`
zNcBD(Z}UOI$ty7h)`wsT8TrCj9QLO<!Iev!OM9CUob`~KIm!n;_*OI3u|a#WpBokr
zYHUYnr#3|0Clu3<Y0Bpk&lu^JZRP@GWVFV#HOn18bUtb4mT|U=*|5yA-nyCRvx2=c
zEwZ1V=<<Og?zoKN05?x;1MdzsmKu~i=@y^%!|4OmZE^=88q|LAd)9k>%k);3lu0hO
z0?-pWeLe+BriUdab<I!jcYMjr9XvxJ#t5%R;Pt;b9lSPD1b%s+u>KwQk!3)GE2qI$
z+>gMgpsz(X3#0Oak#+TfzZ@|uN$HdD>0sZt_~!^PY)BvSk9;*g@h~bpDp(qW!pQM^
z8Dzb<7xJY$zA)B%5d8c>SM&Uy%7#p%xHp>!=nj6}1Z?VrU+0j|#1zwB9Gk8NW9kI2
zfN*jb6kGkinRM~K&IyH$ByUgqRJq@?UQX{M+A$UPaDz9I)|RX%9}N5=Y3s*mdtf~;
zhF*Cz`0mP+cR^((3ne7|CmJ{6pk=<#yLE+2oaO{LOC9W*BEP+QIvv93+?t$%tKs2v
z-?#<z&S^beZ$ql9PGymJL_7pVva9!If-Q#zBZZ0sTZ&t@(C3N51`c_<_J^J{-XDDs
z5Mozxt=Yu<ot)Sw{;E?Yj+6%Bf}|*hZ|1^r=kVHgsK(Ypb?W-T4bmdN&ftRlH=*=5
zNfSxl=wm&rR<89PnkAqK>z2@QLhm?J)}4cpJ8>r)4llHYW}o)wy`UFSys=81q&B=!
zNoD4u>@LhCLFrcU(Ksj$Z;bKF!$OM(?6jJT0{8e6wh{CJs526_jLqmvMN$HqAhhb<
zaLhyWR>E@Dy*?3){ni9W=d;3?w@Xl-rR~w@QfECf-4<fPe0^%m5hplwv`YHU5>`no
z^0uKHM%(%v-V;(5cS-MPOScy<p_+BzOD!>WAEGub(Mm1hXEdB*KBZ00I}l{^3i3Qu
zk75!c9bLoNrW|q=D;u6PDNWh0CKp===fnk@@@8PKVt<H%;%Cu(FTkKW#T<tARg~h+
zLQybSzf5@FeXY<c%WD-75x~(;XscZPqIbWI<7?RBICQlOBtx4dB3k+Wh_vJk4{{dp
zV4+r{^8`2P^aVO5T{J-<niX}yeXiFgv?Cs)HXbdzAeN@>F4wz=_c~MQwceGCCX5Si
zn_6w01&IfK$^`MM_LT^}Ih8~xRFz+Aaq@w%CS8(ET2wW-@l5F~6g!kc9HO1a#PXsy
zOR$bUxakZ_zlCQvZfvHu?q282h!)}I@VwuV73+5|@?6gl?Sw7K?OHqMDh&0|&a<A$
zhtCY~R}`{-HFRY7N%-lpi{1~Elxf9R>a<(;i;Ei{Q*V)5UjV-v^4A}ijhgLTfRDd4
zj}UuJ+-VGp;U9|IbqJCY<;t43=kXfs{3@#8)Y+9Q4lccRCW-t*+82MLl_YEshyz|A
zBLwv%`ayms`N8Y=f%pepxwrI~Q($c}#rLWT)T7>Ys8#Rju|($@NJ5?E?(jzsggP_X
zj`T*AsJ`fP4l4;C7r|OmiCK5vsP3)a+pqmv%%$x2D_?SIX=1PD#B1ZIrUicXa-Sa*
z(?~)rX8$Ds;pVSrz!4eAE|Q$2;1js%2+oIY&W69LQd&32ow-%s0`oX=%k}w@nejn~
z*sWT;O1+74Qx5$6f##a`WR3~z1jEakM?BBr?W2#zU@zF*?$wE%xJ9B>>o#Fm$=7*2
z%4t5*;%a#U#?R8>tQdp&-K?5~;b&wtVLUS9qpxL||4m;ZzS{DU7M8I&t62e6sS_oJ
z!e$#d?)t#8_Q~$%%@Das*Rc|NDm4j<XU_EP2hqld3&n5EZeiEZN!GIA$A|eDh6R28
zJ=-4E^Z0l_%O_t^cRiy0$4R-&>8l3V^Q?W6n%pU|SDudvq3TV0zfdcVHJV_Xro@tU
z>cqz?O`umi8pYZ9rPbN9n?_Li$?5TG=s2~X#~!Zp?k*-;Wyliiw!Mmaknd5hnGpX7
zgT~-9mIo1^3w*bAMs8pdfB5nOr^MCOrNsO|tAgzaLre_4sC&LR0W8}zn(UuZDr01<
zfAYaQA3>E^5|C$6zo^&(BWt~OqR{a{DVjh+IE6LYaRbF`P)CTlpr&0V#8)1E2vz97
zj8|Enos|=)YM-F7cO7>Zl1lb;IK}456w|UO;?`FW2{R0DDfC`;oJeK`w^0XWkWY{Y
zlZ$iHsz-~LB*`gBqkT-Ve7dGNLjqfA{a6RPRpBmY(qkV(4qNdjuw1=M=@+EL@N5Q+
zT+v5)3+qrlor|%Cmy^R!YE+2)C6sNUoEUN}E<55V=eYRZAgaw&nN)N)HP?bm95vGQ
zP8E9Qs-2*kSfJ^`Vusc(Lq41HuwP2HJw0`Lkiv+7f9>G)vu`$BOS>Tt2~0;~IlRo6
zCNWU5m!HX-?y8|{yEKYW<afyAcfsZv9>?gBhr56+e5$lXzP&YmhjDc0NFB<`b)uzh
zJhN}AqI(dhN>2KyvX@xUjOn4U+)hbQRkmBbl>IvDBSi{!!MGr@T=p3<cReEq?Ju2;
zZX=H0m<B>pk_$ucGMdP?<Z?wL?mliuxR9#BQMU4<Nqh7}6L&|SiR?iX>)zRhq1@67
zToDSI(Z>BU^$fSgUNF1o9Zwk4*Ko?Rl4CM1h~n(gofOKx#xarRl<rOCW2L%$;2)P-
z=1zy#NwZ5CQt`G2l6eWflhb<?r{0nr`*2^$SzeW_sOzP=>cK86vlOQRwU+y0r-}6M
z#BRkl3*OQxSFV%1b$tDdL}y{TM(s(YDZhaTtig55jN#cbW6rhCRz=({XwzD6;91mK
znPq@i<*mVJC2|Mt{*=ZeUeZcXDb4rC#c8Qrc4nT3+~dO9n1$Y%5ivAEKN4-C*#pDY
zr0?$wX)*=eO5{tbS09kYvNI>Ih?rK(BW6P|6J)W4J5#hbd0JI5v<YeQaNN|)^uN!L
z@Sa0eE3hd*C&{0p@S|GHEVQO~Qt+TRQcb6)JXGSN6&i7&3K6NImzTU{8cReVF^bs8
zwrqWgG$Z;rfjPrl27ZZfiga@sd4$>bN4Fb03GPG-%_d^Tj1fpc-dg=gwTgL`YPk_=
zD%aTCs8pz=gkxz^dXp4q^!7{B-io$j&k{Mkj_%!0^pwnVNpI7#(H=n+SmoGKN3v6_
zO>%Y8{dbbIrv!f6TdT4elg4ORjlGwJ$pwdM2szN4ss?2A$x7szzT9Qw4bqE=Vi~u=
zS3PPB|G^Y&t09}rBK$tMD#XX8A-Wvx3#SRZiuOw{)=zGhF!y2`{K8K!9r+wgeSRdo
zsI<(<&5l=}<rdcW;@zWy;x8EWi0RA!WK*u@+3Mw&7>K4)Z3%wsLO)RCIj>?bbSGNv
zw@EH1+t+u^-y<HIsZ(#2Hal^Br!Nkq(e24Fo_B3Z?W4}N*U%Ufm77|ADHK4(lM}?f
z^U_09HZ@oK$qtIkLAj7C;+;GeNBdVdy4qr~0W0e|1-|@YAj!td6KHPt%7o0%B+ucu
z`jV`s`DuLm`x5Hr18%zBCPUiY+cE|R)9m$2VxP?oyy_yH3V&KeZ1|w#M;v&$-hRl;
z(h|?HF!j#-TRl#Z(_{7D6QcaQt?Q6tp&S~0Jin*CWUwViHpMizf?PWT<86vjtDo{p
zTb$1lY>OO3gnRD<=6XYk6ULn<xUJKk>jo4m%jNb>dr}4Hi{AE~#W-kl^yR(Vja}Xu
z8#dXy6;~J$`tY%94MOd^n$wz9)Mu<Q3FR<I(GrPK+Y>j-ykhj`um#0~`r>MMdrBXc
zF4U}}V3MZ!R|!pWEy>R?G47JoQ#t~-`Pn<OZtvvz@LqPifgKB>7`a}4t7t{dvGzN}
zIP*IO&Ogcfy*j(gN;<dnlsMzqtJ4qWBqTS6+aAB%G-YDoe<<wdTjAvFO85J#t`xDk
z{m^)tSX}xj8GP+?mf`ysWu$rWv@G!k&YzCrNez-$^PX%B@$^;kOLU6#Q|HjuTiG<@
zf$pO5zeT0;&7Zcr230Dj?HtY?qwN@ubbzv%8>(T`)AH%%vohg`>Y(1oCAxt>!sb^&
zGWspN{B`yM-Mtoq(+D~r0+Udk*u?S&^)&H~K6%ZGT&oK+D^b!tn`i+sUQ&kWZLbsZ
z7d7|&NYRxJ{k*P~O1|mEDIvFyLW@-1e9f-)p{S^WO^3;n6b$vkB}a=6WYrwVK_iw9
zOxIBT*hJ3Nn!xfMo{Bh4fX*`cI2Pwrm^Co*SZTkpYPcDJkD;7a;A3qx&!nwNC-iQh
zLFx=`P-SX{J%>5ng*+#|&;uVu??(?}#nO^{{1J>o$OuePNK9EksXC;duKz}L8$m+$
z_H#X?9Cy?nBO3aP!KQ^=&)><S)a&;8zMq@?+LT1S`7GJV6CW(u17_6UH)ubY>L`ff
zPsugDFQsLfQRx18dlRO}(==y~*%JCz`bjR;-Il5Jl3dT&)Ydheojb4LK`rdMA@^?A
z9=JO-P|@duk8@L5(>27#Ze+yVJ7HR!pdju4gc|LjAWDo19npM;S80}R+fV36Y?nk>
zP#ZEVm-(A{6}ze*k^P{^+WGV|qCKxOc9o;_1f{5)xjkv1DZ7xk(+Ks<7DotNPp&8M
zTJ>PH(rIYGZ1`9BdeK){9^8E+vwi`m%&g$n8)d<An~f8;mFW7i>1HfFhY*2iRBm#c
zT2f_ZKKs-SsOBn}!BDrPe>TfzkW-#OE>Zbm4tI7~O~u%N88ZZQ@)noij<*$#fD0a<
zf8O+(#HSsDTQaVcpYI<ku^@_nQPrRPezdxLC?uoPI7z=uVbPx8^}K<It$1h2{^L+<
z|M<Xwf~qU<|BB#HU$rrXX?`Q{=S6Z}uzAcp?lSgaCv>f}%iRs((G_~cQPN%4+iJVZ
zYflWXjhXaVHEj8e*k;`a&gQo3fUG_#WPb{<j_M5Fw*6#K<D>c9cx2tUejQSzL`lh(
z7#cAlH3|u~YTDZLtba^!h{94x_l#X)Q(8=peQar@x=T&}u#jFOtggmGV~vUP_L1Ns
z{BFGLnY7AW+-eCMeK17jEDA@*(vY%syk4JY&z5KJH#^P;OLArvBR)x(UEB17bw`3K
zE5engGgRdLY_T0U4&~}`Tu!`R6r#&)t+VgC4QYT|3{>z{Lk=!Zwze)MRUY;-RbC~P
zR>c9;&ek~&4g_awhiWPKN~V^b^K-s0jhX*deBLbnl`{OFp^NrO;xba3*`ot|6`vB6
z^541ObG(2d1eOL6Sp*(7cwrC|+{~=-D*niO>)O?JcR(9b+qXy?sokHR|KIif3qC(z
z2%+Bm$MN&_yVMd=b3zcPnFG%2K?lE4f?n(cb0GZphW|N2lGNg?1p@@~0}|OvTreVT
zqblCCX~(!qgQL6^$*fjY5bD+b;GAQmFzowuBFWQ2_L2G*itixNKB-Ve>ZiAuxf-^z
zZv{@DfHVYIz`e|WNP4%S!zsH+il_2pkpywAgOG?eIg=p~%`kqALUtJ+{IiC~Knnzf
z2t*5ltM$-dj*j_1#{?#D_IoBv_ab*NfCmcvl@W~~r!qH3XGhl-Cqh+;yXe-SAUZIH
zFfeDw3Vnf?f(U>|L-`uYP0&AP&odRnpMN6}J6CXCRPSp^aVx6H0XJ}vQRf+qB>{jI
z@SKypEbwpNsG<Mr`+sFKzC=a?)$`oOS9Sj>as3hw)N1~fxX9)Q`Tq-^hwR+H%d&KS
z(4Ff~OGufLFTp^K>Kgo7J@LPZlZjZb`15CW!AmiA><gLq^*68Lk+KY4f`J;*^$Ywa
z8PQ+FE^{z}K!Qj@l7tsRBA9f430cuueJHsG0%@ayKq5#&*U101gbPn<roPG!DTxM>
z%ymjYh6c!{frP)zn*ajwA>nPPFKlcyFkIDtd1LvXT#T0@DhwC+^+pWf4m0jmnLqD$
zUCJ1-U&x3z(O$({_?SIQ20#PA!*~e>YSBCwK6KXMT)*-L;Z%)e!1b|Lycfz;8wsu|
zL%JP-q>MlSz*7tGnA#XSIsG}3E{^{ILvEEF1foL{vyi+nv))K})y)5X<sbuo=|I9a
zJh;HGHBnu~qh-2}>jA5bCP4iB&f8_l)xW?G)g#5E1J^(<6u=(<s}eF^%jg2HhDY(&
z0Q%pj2+)okNIp~eFGJ=VSG_)8py35ABr@kzV5a{}<$oupsf{Jl<UGg9_dHt-0~p1E
z{~Xdartrjkb~sxq&ff+!5$CTe@flpoj1m3;LHb`z&NVW)w>}L6v_%1zSy(Ou0@T7S
z0X!94-2(^7$8#Y8o5y8J01Y%iP!37R`uT;C?;RZf4VDWRRlc7yAa?{hIsVcXYophd
z4otZ;)IX;j*y+NloOTi<ZS)=I+E85J69M9Xdn?s--aF`e!M>mf|1W!PEHhe00E7Zq
z7yq|NUw9$x2IuXRz8ao6lL6Lgz*9Tm3wpj(UzQEe3s1@1X#S>fazT*W8$d9?#Squ8
zYDD@TU#bIYLt*ej8_B=u!a-tDo<Mkx0UDx60*BFXn(lj7mCKc3?nwY)Yy)m}BD;o&
zy`cL60fyuD0G|Kzt-5$Qo}K3bGfjZU<na9M3!?qJ*D@LCWq@DrK=S2*G!}IRKx+?}
zAmT{Wq_Qu}X+S9d@<*nJWMLWL=m~@$Sx6@DLg+^q-Bq8si7k9E03%-k8Ujd0{E9B{
zJe350)5d8%r#(?}F@SU|kUv}JZX<0ukkqz)0fhd34~vYrzvY4VpbT)~M-r&61b9%v
z^INHq;wsg4PT^tI1%+eh8-J5rYdJ@_)B>Z99NuM&yqKJmMBct28LbC4GmKCF*--qq
zak;uB0oKGTMYA3RGI6oAG2?cGm_jV=oq6mXpW8zmoh>22G7JXZ-?>wOTflB63&4Uv
F{|CS?UfTcw

delta 24405
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
Y?_vjpzMBP7I!S;>0t`I!&db{W0XJy*x&QzG

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 23175860..aa8a01af 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Tue Dec 06 21:53:19 EST 2016
+#Mon Feb 27 21:23:04 CET 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip
diff --git a/gradlew b/gradlew
index 9d82f789..4453ccea 100755
--- a/gradlew
+++ b/gradlew
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,26 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -85,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -150,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save ( ) {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index aec99730..e95643d6 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index 4d1a04e9..02f3652a 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -4,16 +4,12 @@ archivesBaseName = "${project.projectName}-${project.name}"
 apply plugin: 'scala'
 
 ext {
-    scalaVersion = "2.11.7"
+    scalaVersion = "2.11.8"
     scalacheckScalaVersion = "2.11"
-    scalacheckVersion = "1.12.4"
+    scalacheckVersion = "1.12.5"
     signModule = true
 }
 
-tasks.withType(ScalaCompile) {
-    scalaCompileOptions.useAnt = false
-}
-
 dependencies {
     compile project(":core")
     compile "org.scala-lang:scala-library:$scalaVersion"
@@ -22,8 +18,6 @@ dependencies {
     testCompile dependencyJunit
 }
 
-sourceCompatibility = "1.7"
-
 performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)
 

From 6fa8bce2008c73d5995af20f6f41f60908e2ca6d Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 23 Oct 2016 12:49:34 +0200
Subject: [PATCH 165/336] add "_1.8" suffix to artifact cross-built for java 8.
 Use JDK7 as retrolambda target

---
 .travis.yml             | 1 -
 build.gradle            | 8 ++++----
 java-core/build.gradle  | 2 ++
 java8/build.gradle      | 4 +++-
 lib.gradle              | 2 ++
 quickcheck/build.gradle | 4 ++--
 6 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 4a7c9290..8f3091d1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -24,7 +24,6 @@ before_script:
   - sudo service x11-common stop || true
 
 script:
-  - jdk_switcher use openjdk6 && export JAVA6_HOME=$JAVA_HOME
   - jdk_switcher use oraclejdk7 && export JAVA7_HOME=$JAVA_HOME
   - jdk_switcher use oraclejdk8 && export JAVA8_HOME=$JAVA_HOME
   - ./gradlew build coverage -s -i
diff --git a/build.gradle b/build.gradle
index 1ccd524a..5bedc102 100644
--- a/build.gradle
+++ b/build.gradle
@@ -6,8 +6,8 @@ ext {
 
 buildscript {
     ext {
-		uptodateVersion = "1.6.0"
-        retrolambdaPluginVersion = "3.2.5"
+		uptodateVersion = "1.6.2"
+        retrolambdaPluginVersion = "3.3.1"
         retrolambdaVersion = "2.3.0"
     }
 
@@ -77,8 +77,8 @@ allprojects {
         displayCompilerWarnings = true
 
         newJdkEnvVar = "JAVA8_HOME"
-        oldJdkEnvVar = "JAVA6_HOME"
-        retroLambdaTarget = JavaVersion.VERSION_1_6
+        oldJdkEnvVar = "JAVA7_HOME"
+        retroLambdaTarget = JavaVersion.VERSION_1_7
     }
 
     repositories {
diff --git a/java-core/build.gradle b/java-core/build.gradle
index 88e9a25f..6a92cc28 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -1,5 +1,6 @@
 
 archivesBaseName = "${project.projectName}-${project.name}"
+configureAllRetroLambda()
 
 ext {
     signModule = true
@@ -13,4 +14,5 @@ dependencies {
 performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)
 
+
 uploadArchives.enabled = true
diff --git a/java8/build.gradle b/java8/build.gradle
index 88e9a25f..d6d4c485 100644
--- a/java8/build.gradle
+++ b/java8/build.gradle
@@ -13,4 +13,6 @@ dependencies {
 performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)
 
-uploadArchives.enabled = true
+if (!useRetroLambda) {
+    uploadArchives.enabled = true
+}
diff --git a/lib.gradle b/lib.gradle
index 28be5e34..253ed251 100644
--- a/lib.gradle
+++ b/lib.gradle
@@ -94,6 +94,8 @@ void configureRetroLambda(boolean useRetroLambda, String newJdkEnvVar, String ol
         dependencies {
             retrolambdaConfig "net.orfjackal.retrolambda:retrolambda:$retrolambdaVersion"
         }
+    } else {
+        project.archivesBaseName = "${project.archivesBaseName}_1.8"
     }
 }
 
diff --git a/quickcheck/build.gradle b/quickcheck/build.gradle
index 4d3a25be..45e379da 100644
--- a/quickcheck/build.gradle
+++ b/quickcheck/build.gradle
@@ -3,10 +3,10 @@ ext {
     signModule = true
 }
 
-configureAllRetroLambda()
-
 archivesBaseName = "${project.projectName}-${project.name}"
 
+configureAllRetroLambda()
+
 dependencies {
 	compile project(":core")
     compile dependencyJunit

From 3dcdf401182899611608537dd9862f06eed18062 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Feb 2017 21:18:51 +0100
Subject: [PATCH 166/336] java-core module should be publish with retrolambda
 processing.

---
 java-core/build.gradle | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/java-core/build.gradle b/java-core/build.gradle
index 6a92cc28..032c2ca5 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -16,3 +16,5 @@ configureUpload(signingEnabled, signModule)
 
 
 uploadArchives.enabled = true
+
+configureAllRetroLambda()
\ No newline at end of file

From d1b15e16f8287b1265efc6516801aba29abdd290 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Feb 2017 21:25:41 +0100
Subject: [PATCH 167/336] upgrade to latest retrolambda version.

---
 build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 5bedc102..b9597063 100644
--- a/build.gradle
+++ b/build.gradle
@@ -7,8 +7,8 @@ ext {
 buildscript {
     ext {
 		uptodateVersion = "1.6.2"
-        retrolambdaPluginVersion = "3.3.1"
-        retrolambdaVersion = "2.3.0"
+        retrolambdaPluginVersion = "3.5.0"
+        retrolambdaVersion = "2.5.1"
     }
 
     repositories {

From 0759750518cfbd920170d75c73c199d80b5bb49e Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 17 Mar 2017 00:43:54 +1000
Subject: [PATCH 168/336] Added release notes for 4.7

---
 etc/release-notes/release-notes-4.7.adoc | 44 ++++++++++++++++++++----
 1 file changed, 37 insertions(+), 7 deletions(-)

diff --git a/etc/release-notes/release-notes-4.7.adoc b/etc/release-notes/release-notes-4.7.adoc
index 3c1b265f..6f5958de 100644
--- a/etc/release-notes/release-notes-4.7.adoc
+++ b/etc/release-notes/release-notes-4.7.adoc
@@ -1,28 +1,58 @@
 
 = Release 4.7
 
-Proposed release: September 2016
+Released: unknown, potentially 25 March 2017
 
 == Enhancements
 
-* TODO.
+* Added Hash Array Mapped Trie (#284).
+* Improve performance of List#groupBy via a mutable buffer (#288).
+* Avoid unnecessary wrapping of F0 into P1.lazy where applicable.  Use static P factories for this (#284).
+* Added semigroup constraint to List.traverseValidation (#287).
+* Added first class fold for either (catamorphism) (#284).
+* Added first class fold for Option (catamorphism) (#284).
+* Added optimisable definitions for Equal (#284).
+* Added uncurried version of foldRight, foldLeft and append to NonEmptyList (#284).
+* Added optimisable definitions for Monoid and Semigroup (#284).
+* Improved performance of List.minimum and maximum by using uncurried Ord.max and Ord.min (#284).
+* Removed deprecation of Monoid, Ord and Semigroup constructors for non Java 8 versions (#284).
+* Added safe List minimumOption and maximumOption and NonEmptyList minimum and maximum.
+* Added  Set.lookup, Set.lookupLT, Set.lookupGT, Set.lookupLE and Set.lookupGE from Haskell (#305).
 
 == Fixes
 
-* TODO.
+* Make Stream conversions respect laziness (#284).
+* Fixed Ord#isGreaterThan(A)/isLesserThan(A) not using strict inequality (#293).
+* Correctly convert Option.some(null) to Optional (#284).
+* Fixed override in P.p(A) (#284).
+* Avoid unnecessary currying in uncurried version of foldRight (#284).
 
 == Internal
 
-* TODO.
+* Deprecated unsafe Ord instance and List#groupBy without an Ord parameter (#290).
+* Added tests for Strings class (#295).
+* Use more method references (#284).
+* Converted memoisation tests from JUnit to PropertyTestRunner (#284) for hard memoisation.
+* Improved implementation of P1#_1 method (#284).
+* Make use of weak memoisation explicit (#284).
+* Enable backport of default methods using Retro Lambda (#284).
+* Upgrade to Gradle 2.14.1 (#310).
+* Switch from Coveralls to cover.io (#308).
+* Force strict evaluation in TreeMap.map (#309).
 
 == Breaking Changes
 
-* TODO.
+* none.
 
 == Documentation
 
-* TODO.
+* none.
 
 == Contributors
 
-* TODO.
+* Jean-Baptiste Giradeau
+* Mark Perry
+* Gabor Liptak
+* Shimi Bandiel
+* Siro Mateos
+

From 1faf5b9184d82cca5929747f5cfb4e67100752ab Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 25 Mar 2017 18:12:58 +0100
Subject: [PATCH 169/336] Make retrolambda target java 6.

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index b9597063..6c417b5c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -78,7 +78,7 @@ allprojects {
 
         newJdkEnvVar = "JAVA8_HOME"
         oldJdkEnvVar = "JAVA7_HOME"
-        retroLambdaTarget = JavaVersion.VERSION_1_7
+        retroLambdaTarget = JavaVersion.VERSION_1_6
     }
 
     repositories {

From 4d36fcddcf9899191899d83ec80546e41c528bac Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Mar 2017 20:58:13 +0200
Subject: [PATCH 170/336] Update gradle wrapper to 3.4.1

---
 gradle/wrapper/gradle-wrapper.jar        | Bin 54208 -> 54208 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 7f9251933fd4846b7f2c971bb2c5f6a575ad3e3a..2dcd00d1ccd90b5b3d39e0da139893d5e7651ae4 100644
GIT binary patch
delta 957
zcmYL{Ye<t(7{|}{YFm?;mjz~+mk+B!Wr<kL?)NrZ+7_+c=4ECVyO`lv*@uF@^&#~{
zBq<hJ6NCjVibT-1xvRUVNEaxwD3QJ>R2CHVzW+1q!^`jYJm-H7=RM~PJGfy7Cok7>
zNeV)wQqo{Ew8@oH9vWZXgMDqKMn%VL(_E8?{Lh&9j3b{D5MBlRSSP@x63G?|LQ7=R
zXym1+B#^R<p+%6?WfCzYYq^EV<(zj(=o~9ZXW?_I4aq`>I@V5M<Yr+j%dRLg$kA!u
zX3T`d4^PV=1Lj_qsi}Sgp<ApbPS3B>X<aSQ6}Em5L!9+<;#9t)DYz0m-kwZIhn!yT
zSxOt7DXz%rzGQ^#7y6N=%BGogA>4V^6my6OdBhR2k<Qt2Xd0Ecc3%pJkYCa~#^jUD
z%w(7SSrUeRUoGVz>T7)&kk9S8Qi$YUoQ2<ZQkH4F&oQy}OiGZ^_5Wr2E_d!=3*LTW
zV4bf|XPCTtKFcIDK-q%TgSi~`-5U6IXS0|PJ^!QYX@xzT{u$49d58950+qXUT+R6w
zYH_Rcg-e!5w;!0y$|QuO^Iy4EBvz1xr$Jx1ix=Jo{q9x^M^B49g<zeh1nlx`1>bx0
zV6pcgc*9!(zV=$cO(RyYd!z~!`6|IGAIm@X8BxppI<V5O0sH)A;JjZ8?g<<Ly8<l#
zGeLb&CmbN{4XVMZpat9+V(bZ3pq>w11RKJ7@MYKvt{go9-WoN4Uq<V}Ly<G!V1&(2
zi=IN=60HM2Mp;f9JBs>YjOBjCPNKHP86$Bs>NR6*{@nz*arSU)$7?a}Pt?i@jg-GC
Ljc`HKKC%BF8^&kK

delta 957
zcmYL{T}YEr7{|}{s#}wpQ-d_jR9Fd>C1N%Epig46HJg#8PIG48WDCbiFA}1gE>cfK
z(WF3YBVkdCA`!H0x^Fj?KB-8hM7l}JEKurw|7Y06%kTF*=YJ08J?He>xPBWa*J-%8
zG(x0OB5TfVlPje>)UW4SX4;C&)6##KrcEO9KQrHy+h)t=1O!(Bzt#zG=80sB1ffN;
zNi<d@=1CwWDSZi$q;!cGvUHh&$;Hf%ap)Y*QLymYybbX}huYSTVdPqVE6Xk~D3hbp
zxUD=D5<M^}gY;B&vCPq$cM!V8Sjo-st5}Vz1v-Pq&tiz9ep;NwchotT{72g33Art&
zEuBkfgCo%yK536f$a1b5X{t0$DTJ`~Ol8C-BIE%_$VNJC&ZNmy;@ow?CqjO4<1mv6
za}|@FmS=GonrklRAgasu6v&tMEGa~CC(6R_t(0XN?r}`aov$RwXuJQied`?C*@8Eo
zl(EjYr&CPcJpaxl&_mgRHN9CJ_TB3Hd2_Rv5Iz5+>uISagU*j+I6ZxPFoDWlT5kMd
z1vR)-*$Mn5OQaJY9$!r*gedq=rxA(M$ima0FI<HSZ-dUbRKn5I0(U-G=Pm*}+*`p<
zZarA&*#}<nl!9+P25{4W5xhH44T=UU!0JJke>7N*TISV)6<#%H_m+UOUJbb0cM$CG
zvHb5C^?t2zfV9i60>}IYa7Tc#Gf;|pHgFz19n^y_gGO*==oolCR0e(x)r0%Pr@-DY
zo1Z*%0(H|+9XLM3a+=5?)b}GS_a|~3wK2*Vj#i;wGtB1Sijf;(54U!t7USMntsGTL
O`KwY37ep<id;bB7jh2uA

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index aa8a01af..7a57ac51 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
-#Mon Feb 27 21:23:04 CET 2017
+#Mon Mar 27 13:51:02 CEST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.4.1-bin.zip

From 5e1e129caa471ff05e50a2ab790c9a0d088a65a2 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Mar 2017 20:58:59 +0200
Subject: [PATCH 171/336] java-core build: remove duplicate call of
 configureAllRetroLambda()

---
 java-core/build.gradle | 1 -
 1 file changed, 1 deletion(-)

diff --git a/java-core/build.gradle b/java-core/build.gradle
index 032c2ca5..3b636072 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -1,6 +1,5 @@
 
 archivesBaseName = "${project.projectName}-${project.name}"
-configureAllRetroLambda()
 
 ext {
     signModule = true

From 8fb59b9f1ed3771296c4a164e5cde4439a4e82c4 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Mar 2017 21:17:53 +0200
Subject: [PATCH 172/336] 4.7 release.

---
 README.adoc                              | 22 +++++++++++-----------
 build.gradle                             |  2 +-
 etc/release-notes/release-notes-4.7.adoc |  2 +-
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/README.adoc b/README.adoc
index 418605de..6c5d3c1e 100644
--- a/README.adoc
+++ b/README.adoc
@@ -31,16 +31,16 @@ The recommended way to download and use the project is through your build tool.
 
 The Functional Java artifact is published to Maven Central using the group `org.functionaljava` with three published artifacts:
 
-* the core library (`functionaljava`)
+* the core library (`functionaljava` or `functionaljava_1.8` if you use Java 8+)
 * Java 8 specific support (`functionaljava-java8`)
-* property based testing (`functionaljava-quickcheck`)
+* property based testing (`functionaljava-quickcheck` or `functionaljava-quickcheck_1.8` if you use Java 8+)
 
-The latest stable version is `4.6`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `4.7`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.6"
-compile "org.functionaljava:functionaljava-java8:4.6"
-compile "org.functionaljava:functionaljava-quickcheck:4.6"
-compile "org.functionaljava:functionaljava-java-core:4.6"
+compile "org.functionaljava:functionaljava:4.7"
+compile "org.functionaljava:functionaljava-java8:4.7"
+compile "org.functionaljava:functionaljava-quickcheck:4.7"
+compile "org.functionaljava:functionaljava-java-core:4.7"
 ----
 
 and in Maven:
@@ -48,22 +48,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.6</version>
+    <version>4.7</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java8</artifactId>
-    <version>4.6</version>
+    <version>4.7</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.6</version>
+    <version>4.7</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java-core</artifactId>
-    <version>4.6</version>
+    <version>4.7</version>
 </dependency>
 ----
 
diff --git a/build.gradle b/build.gradle
index 6c417b5c..c0152d08 100644
--- a/build.gradle
+++ b/build.gradle
@@ -46,7 +46,7 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = true
+        isSnapshot = false
         fjBaseVersion = "4.7"
 
         snapshotAppendix = "-SNAPSHOT"
diff --git a/etc/release-notes/release-notes-4.7.adoc b/etc/release-notes/release-notes-4.7.adoc
index 6f5958de..428a0726 100644
--- a/etc/release-notes/release-notes-4.7.adoc
+++ b/etc/release-notes/release-notes-4.7.adoc
@@ -1,7 +1,7 @@
 
 = Release 4.7
 
-Released: unknown, potentially 25 March 2017
+Released: 27 March 2017
 
 == Enhancements
 

From 0ff3a9c27425736994f6f336aec68e40b6183884 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 27 Mar 2017 21:46:59 +0200
Subject: [PATCH 173/336] Prepare next iteration.

---
 build.gradle                             |  6 ++---
 etc/release-notes/release-notes-4.8.adoc | 28 ++++++++++++++++++++++++
 2 files changed, 31 insertions(+), 3 deletions(-)
 create mode 100644 etc/release-notes/release-notes-4.8.adoc

diff --git a/build.gradle b/build.gradle
index c0152d08..04209664 100644
--- a/build.gradle
+++ b/build.gradle
@@ -46,12 +46,12 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = false
-        fjBaseVersion = "4.7"
+        isSnapshot = true
+        fjBaseVersion = "4.8"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.6"
+        fjConsumeVersion = "4.7"
 
         signModule = false
         useRetroLambda = false
diff --git a/etc/release-notes/release-notes-4.8.adoc b/etc/release-notes/release-notes-4.8.adoc
new file mode 100644
index 00000000..22dbc552
--- /dev/null
+++ b/etc/release-notes/release-notes-4.8.adoc
@@ -0,0 +1,28 @@
+
+= Release <version>
+
+Proposed release: <quarter> <year>
+
+== Enhancements
+
+* TODO.
+
+== Fixes
+
+* TODO.
+
+== Internal
+
+* TODO.
+
+== Breaking Changes
+
+* TODO.
+
+== Documentation
+
+* TODO.
+
+== Contributors
+
+* TODO.

From 07f94fa172d9465de69abea188ecbdbc73c09078 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Mon, 1 May 2017 21:44:09 -0500
Subject: [PATCH 174/336] Fixed a bug in the NonEmptyList Semigroup
 implementation that resulted in the same NonEmptyList appended to itself.

---
 core/src/main/java/fj/Semigroup.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 74d7de9b..16b0d130 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -534,7 +534,7 @@ public static <A> Semigroup<NonEmptyList<A>> nonEmptyListSemigroup() {
     return semigroupDef(new Definition<NonEmptyList<A>>() {
       @Override
       public NonEmptyList<A> append(NonEmptyList<A> a1, NonEmptyList<A> a2) {
-        return a1.append(a1);
+        return a1.append(a2);
       }
 
       @Override

From 405c3ec31351bf8518bfec8b91bf8be66056991b Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Mon, 1 May 2017 21:44:46 -0500
Subject: [PATCH 175/336] Added Scalacheck Arbitrary implementations for
 Natural and NonEmptyList.

---
 .../main/scala/fj/data/ArbitraryNatural.scala    | 13 +++++++++++++
 .../scala/fj/data/ArbitraryNonEmptyList.scala    | 16 ++++++++++++++++
 2 files changed, 29 insertions(+)
 create mode 100644 props-core-scalacheck/src/main/scala/fj/data/ArbitraryNatural.scala
 create mode 100644 props-core-scalacheck/src/main/scala/fj/data/ArbitraryNonEmptyList.scala

diff --git a/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNatural.scala b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNatural.scala
new file mode 100644
index 00000000..4210eef7
--- /dev/null
+++ b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNatural.scala
@@ -0,0 +1,13 @@
+package fj.data
+
+import org.scalacheck.Arbitrary
+
+/**
+  * A Scalacheck [[Arbitrary]] for [[Natural]].
+  */
+object ArbitraryNatural {
+
+  implicit def arbitraryNatural: Arbitrary[Natural] =
+    Arbitrary(Arbitrary.arbBigInt.arbitrary.map(_.abs).map(bi => Natural.natural(bi.bigInteger).some()))
+
+}
diff --git a/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNonEmptyList.scala b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNonEmptyList.scala
new file mode 100644
index 00000000..2258ba9b
--- /dev/null
+++ b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryNonEmptyList.scala
@@ -0,0 +1,16 @@
+package fj.data
+
+import fj.data.NonEmptyList.nel
+import org.scalacheck.Arbitrary.arbitrary
+import org.scalacheck.{Arbitrary, Gen}
+
+/**
+  * A Scalacheck [[Arbitrary]] for [[NonEmptyList]].
+  */
+object ArbitraryNonEmptyList {
+  implicit def arbitraryNonEmptyList[A](implicit a: Arbitrary[A]): Arbitrary[NonEmptyList[A]] =
+    Arbitrary(nelOf(arbitrary[A]))
+
+  def nelOf[A](g: => Gen[A]): Gen[NonEmptyList[A]] =
+    Gen.nonEmptyListOf(g).map(l => l.tail.foldRight(nel(l.head))((x, n) => n.cons(x)))
+}

From ef811305b0e60e8b4dd5e42c601c8b3cbfed1fe7 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Tue, 2 May 2017 00:15:25 -0500
Subject: [PATCH 176/336] Added unit test coverage for Semigroup
 implementations.  The StringBuffer and StringBuilder tests fail because both
 of those types are mutable.  The IO test fails because the ArbitraryIO
 implementation does not implement equals.

---
 .../src/main/scala/fj/data/ArbitraryIO.scala  |  22 +++
 .../src/test/scala/fj/CheckSemigroup.scala    | 152 ++++++++++++++++++
 2 files changed, 174 insertions(+)
 create mode 100644 props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
 create mode 100644 props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala

diff --git a/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
new file mode 100644
index 00000000..7667840b
--- /dev/null
+++ b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
@@ -0,0 +1,22 @@
+package fj.data
+
+import org.scalacheck.Arbitrary
+
+/**
+  *
+  */
+object ArbitraryIO {
+
+  implicit def arbitraryIO[T](implicit arbT: Arbitrary[T]): Arbitrary[IO[T]] =
+    Arbitrary(arbT.arbitrary.map(t => new IO[T]() {
+
+      override def run(): T = t
+
+      override def toString: String = t.toString
+
+      override def hashCode(): Int = t.hashCode()
+
+      override def equals(obj: scala.Any): Boolean = ???
+    }))
+
+}
diff --git a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
new file mode 100644
index 00000000..933bedc6
--- /dev/null
+++ b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
@@ -0,0 +1,152 @@
+package fj
+
+import fj.ArbitraryP._
+import fj.ArbitraryUnit.arbitraryUnit
+import fj.Ord.intOrd
+import fj.data.ArbitraryArray.arbitraryArray
+import fj.data.ArbitraryIO.arbitraryIO
+import fj.data.ArbitraryList.arbitraryList
+import fj.data.ArbitraryNatural.arbitraryNatural
+import fj.data.ArbitraryNonEmptyList.arbitraryNonEmptyList
+import fj.data.ArbitraryOption.arbitraryOption
+import fj.data.ArbitrarySet.arbitrarySet
+import fj.data.ArbitraryStream.arbitraryStream
+import org.scalacheck.Arbitrary._
+import org.scalacheck.Prop._
+import org.scalacheck.{Arbitrary, Properties}
+
+/**
+  * Scalacheck [[Properties]] for [[Semigroup]] implementations.
+  *
+  * @param s         a Semigroup implementation.
+  * @param desc      a description of the Semigroup implementation.
+  * @param arbitrary a Scalacheck [[Arbitrary]] implementation for the Semigroup's type.
+  * @tparam T the type to which the Semigroup applies.
+  */
+case class SemigroupProperties[T](s: Semigroup[T], desc: String)(implicit val arbitrary: Arbitrary[T]) extends Properties(desc) {
+
+
+  property("sum(x,y)") = forAll((x: T, y: T, z: T) =>
+    s.sum(s.sum(x, y), z) == s.sum(x, s.sum(y, z)))
+
+  property("sum()") = forAll((x: T, y: T, z: T) => {
+    val sf = s.sum()
+    sf.f(sf.f(x).f(y)).f(z) == sf.f(x).f(sf.f(y).f(z))
+  })
+
+  property("dual()") = forAll((x: T, y: T, z: T) => {
+    val sd = s.dual()
+    sd.sum(sd.sum(x, y), z) == sd.sum(x, sd.sum(y, z))
+  })
+
+  property("sum(x)") = forAll((x: T, y: T) =>
+    s.sum(x).f(y) == s.sum(x, y))
+
+}
+
+
+/**
+  *
+  */
+object CheckSemigroup extends Properties("Semigroup") {
+
+
+  def idInt(n: Int): java.lang.Integer = n
+
+  implicit def oi: Ord[Int] = intOrd.contramap(idInt _)
+
+  implicit lazy val arbJavaBigDecimal: Arbitrary[java.math.BigDecimal] = Arbitrary(
+    Arbitrary.arbLong.arbitrary.map(l => new java.math.BigDecimal(l))
+  )
+
+  implicit lazy val arbJavaBigInteger: Arbitrary[java.math.BigInteger] = Arbitrary(
+    Arbitrary.arbBigInt.arbitrary.map(_.bigInteger)
+  )
+
+  implicit lazy val arbJavaInteger: Arbitrary[Integer] = Arbitrary(
+    Arbitrary.arbInt.arbitrary.map(i => i)
+  )
+
+  implicit lazy val arbJavaLong: Arbitrary[java.lang.Long] = Arbitrary(
+    Arbitrary.arbLong.arbitrary.map(i => i)
+  )
+
+  implicit lazy val arbJavaBoolean: Arbitrary[java.lang.Boolean] = Arbitrary(
+    Arbitrary.arbBool.arbitrary.map(b => b)
+  )
+
+  implicit lazy val arbStringBuilder: Arbitrary[java.lang.StringBuilder] = Arbitrary(
+    Arbitrary.arbString.arbitrary.map(new java.lang.StringBuilder(_))
+  )
+
+  implicit lazy val arbStringBuffer: Arbitrary[StringBuffer] = Arbitrary(
+    Arbitrary.arbString.arbitrary.map(new StringBuffer(_))
+  )
+
+  include(SemigroupProperties(Semigroup.arraySemigroup[Int](), "arraySemigroup()"))
+
+  include(SemigroupProperties(Semigroup.bigdecimalAdditionSemigroup, "bigdecimalAdditionSemigroup"))
+  include(SemigroupProperties(Semigroup.bigdecimalMultiplicationSemigroup, "bigdecimalMultiplicationSemigroup"))
+  include(SemigroupProperties(Semigroup.bigDecimalMaximumSemigroup, "bigDecimalMaximumSemigroup"))
+  include(SemigroupProperties(Semigroup.bigDecimalMinimumSemigroup, "bigDecimalMinimumSemigroup"))
+
+  include(SemigroupProperties(Semigroup.bigintAdditionSemigroup, "bigintAdditionSemigroup"))
+  include(SemigroupProperties(Semigroup.bigintMultiplicationSemigroup, "bigintMultiplicationSemigroup"))
+  include(SemigroupProperties(Semigroup.bigintMaximumSemigroup, "bigintMaximumSemigroup"))
+  include(SemigroupProperties(Semigroup.bigintMinimumSemigroup, "bigintMinimumSemigroup"))
+
+  include(SemigroupProperties(Semigroup.conjunctionSemigroup, "conjunctionSemigroup"))
+  include(SemigroupProperties(Semigroup.disjunctionSemigroup, "disjunctionSemigroup"))
+  include(SemigroupProperties(Semigroup.exclusiveDisjunctionSemiGroup, "exclusiveDisjunctionSemiGroup"))
+
+  include(SemigroupProperties(Semigroup.firstOptionSemigroup[Int](), "firstOptionSemigroup()"))
+  include(SemigroupProperties(Semigroup.firstSemigroup[Int](), "firstSemigroup()"))
+
+  include(SemigroupProperties(Semigroup.intAdditionSemigroup, "intAdditionSemigroup"))
+  include(SemigroupProperties(Semigroup.intMultiplicationSemigroup, "intMultiplicationSemigroup"))
+  include(SemigroupProperties(Semigroup.intMaximumSemigroup, "intMaximumSemigroup"))
+  include(SemigroupProperties(Semigroup.intMinimumSemigroup, "intMinimumSemigroup"))
+
+  include(SemigroupProperties(Semigroup.ioSemigroup[String](Semigroup.stringSemigroup), "ioSemigroup(Semigroup)"))
+
+  include(SemigroupProperties(Semigroup.lastOptionSemigroup[Int](), "lastOptionSemigroup()"))
+  include(SemigroupProperties(Semigroup.lastSemigroup[Int](), "lastSemigroup()"))
+
+  include(SemigroupProperties(Semigroup.longAdditionSemigroup, "longAdditionSemigroup"))
+  include(SemigroupProperties(Semigroup.longMultiplicationSemigroup, "longMultiplicationSemigroup"))
+  include(SemigroupProperties(Semigroup.longMaximumSemigroup, "longMaximumSemigroup"))
+  include(SemigroupProperties(Semigroup.longMinimumSemigroup, "longMinimumSemigroup"))
+
+
+  include(SemigroupProperties(Semigroup.listSemigroup[Int], "listSemigroup"))
+
+  include(SemigroupProperties(Semigroup.naturalAdditionSemigroup, "naturalAdditionSemigroup"))
+  include(SemigroupProperties(Semigroup.naturalMaximumSemigroup, "naturalMaximumSemigroup"))
+  include(SemigroupProperties(Semigroup.naturalMinimumSemigroup, "naturalMinimumSemigroup"))
+  include(SemigroupProperties(Semigroup.naturalMultiplicationSemigroup, "naturalMultiplicationSemigroup"))
+
+  include(SemigroupProperties(Semigroup.nonEmptyListSemigroup[Int], "nonEmptyListSemigroup"))
+
+  include(SemigroupProperties(Semigroup.p1Semigroup(Semigroup.intAdditionSemigroup), "p1Semigroup(Semigroup<A>)"))
+  include(SemigroupProperties(Semigroup.p2Semigroup(Semigroup.intAdditionSemigroup, Semigroup.stringSemigroup), "p2Semigroup(Semigroup<A>,Semigroup<B>)"))
+
+  include(SemigroupProperties(Semigroup.semigroup[Int](new F2[Int, Int, Int] {
+    def f(x: Int, y: Int): Int = x + y
+  }), "semigroup(F<A,A,A>)"))
+
+  include(SemigroupProperties(Semigroup.semigroup[Int](new F[Int, F[Int, Int]] {
+    def f(x: Int): F[Int, Int] = (y: Int) => x + y
+  }), "semigroup(F<A,F<A,A>>)"))
+
+  include(SemigroupProperties(Semigroup.setSemigroup[Int](), "setSemigroup()"))
+  include(SemigroupProperties(Semigroup.streamSemigroup[Int](), "streamSemigroup"))
+
+  include(SemigroupProperties(Semigroup.stringSemigroup, "stringSemigroup"))
+  include(SemigroupProperties(Semigroup.stringBufferSemigroup, "stringBufferSemigroup"))
+  include(SemigroupProperties(Semigroup.stringBuilderSemigroup, "stringBuilderSemigroup"))
+
+
+  include(SemigroupProperties(Semigroup.unitSemigroup, "unitSemigroup"))
+
+
+}

From a8e979fc78e0cdd4e33e86d32b0394edcc065e47 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Tue, 2 May 2017 22:51:29 -0500
Subject: [PATCH 177/336] Fixed the ArbitraryIO implementation and created a
 Properties object for testing the IO semigroup.

---
 .../src/main/scala/fj/data/ArbitraryIO.scala  | 14 ++---
 .../src/test/scala/fj/CheckSemigroup.scala    | 57 ++++++++++++++++++-
 2 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
index 7667840b..aca5cbd1 100644
--- a/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
+++ b/props-core-scalacheck/src/main/scala/fj/data/ArbitraryIO.scala
@@ -7,16 +7,12 @@ import org.scalacheck.Arbitrary
   */
 object ArbitraryIO {
 
-  implicit def arbitraryIO[T](implicit arbT: Arbitrary[T]): Arbitrary[IO[T]] =
-    Arbitrary(arbT.arbitrary.map(t => new IO[T]() {
-
-      override def run(): T = t
 
-      override def toString: String = t.toString
+  private case class ArbIO[T](value: T) extends IO[T] {
+    override def run(): T = value
+  }
 
-      override def hashCode(): Int = t.hashCode()
-
-      override def equals(obj: scala.Any): Boolean = ???
-    }))
+  implicit def arbitraryIO[T](implicit arbT: Arbitrary[T]): Arbitrary[IO[T]] =
+    Arbitrary(arbT.arbitrary.map(ArbIO(_)))
 
 }
diff --git a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
index 933bedc6..1305efe9 100644
--- a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
+++ b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
@@ -11,12 +11,13 @@ import fj.data.ArbitraryNonEmptyList.arbitraryNonEmptyList
 import fj.data.ArbitraryOption.arbitraryOption
 import fj.data.ArbitrarySet.arbitrarySet
 import fj.data.ArbitraryStream.arbitraryStream
+import fj.data.IO
 import org.scalacheck.Arbitrary._
 import org.scalacheck.Prop._
 import org.scalacheck.{Arbitrary, Properties}
 
 /**
-  * Scalacheck [[Properties]] for [[Semigroup]] implementations.
+  * Scalacheck [[Properties]] parameterized for [[Semigroup]] implementations.
   *
   * @param s         a Semigroup implementation.
   * @param desc      a description of the Semigroup implementation.
@@ -44,9 +45,59 @@ case class SemigroupProperties[T](s: Semigroup[T], desc: String)(implicit val ar
 
 }
 
+/**
+  * A specialized Scalacheck [[Properties]] object for testing the [[Semigroup.ioSemigroup()]] method.
+  */
+object CheckIOSemigroup extends Properties("ioSemigroup") {
+
+  val s = Semigroup.ioSemigroup(Semigroup.stringSemigroup)
+
+  property("sum(x,y)") = forAll((x: IO[String], y: IO[String], z: IO[String]) =>
+    s.sum(s.sum(x, y), z).run() == s.sum(x, s.sum(y, z)).run())
+
+  property("sum()") = forAll((x: IO[String], y: IO[String], z: IO[String]) => {
+    val sf = s.sum()
+    sf.f(sf.f(x).f(y)).f(z).run() == sf.f(x).f(sf.f(y).f(z)).run()
+  })
+
+  property("dual()") = forAll((x: IO[String], y: IO[String], z: IO[String]) => {
+    val sd = s.dual()
+    sd.sum(sd.sum(x, y), z).run() == sd.sum(x, sd.sum(y, z)).run()
+  })
+
+  property("sum(x)") = forAll((x: IO[String], y: IO[String]) =>
+    s.sum(x).f(y).run() == s.sum(x, y).run())
+
+}
+
+object CheckStringBuilder extends Properties("stringBuilderSemigroup") {
+
+  val s: Semigroup[java.lang.StringBuilder] = Semigroup.stringBuilderSemigroup
+
+  implicit def toStringBuilder(str: String): java.lang.StringBuilder = new java.lang.StringBuilder(str)
+
+  property("sum(x,y)") = forAll((x: String, y: String, z: String) =>
+    s.sum(s.sum(x, y), z).toString == s.sum(x, s.sum(y, z)).toString
+  )
+
+  property("sum()") = forAll((x: String, y: String, z: String) => {
+    val sf = s.sum()
+    sf.f(sf.f(x).f(y)).f(z).toString == sf.f(x).f(sf.f(y).f(z.toString))
+  })
+
+  property("dual()") = forAll((x: String, y: String, z: String) => {
+    val sd = s.dual()
+    sd.sum(sd.sum(x, y), z).toString == sd.sum(x, sd.sum(y, z).toString)
+  })
+
+  property("sum(x)") = forAll((x: String, y: String) =>
+    s.sum(x).f(y).toString == s.sum(x, y).toString)
+
+}
+
 
 /**
-  *
+  * A Scalacheck [[Properties]] object that aggregates the tests for all [[Semigroup]] implementations.
   */
 object CheckSemigroup extends Properties("Semigroup") {
 
@@ -107,7 +158,7 @@ object CheckSemigroup extends Properties("Semigroup") {
   include(SemigroupProperties(Semigroup.intMaximumSemigroup, "intMaximumSemigroup"))
   include(SemigroupProperties(Semigroup.intMinimumSemigroup, "intMinimumSemigroup"))
 
-  include(SemigroupProperties(Semigroup.ioSemigroup[String](Semigroup.stringSemigroup), "ioSemigroup(Semigroup)"))
+  include(CheckIOSemigroup)
 
   include(SemigroupProperties(Semigroup.lastOptionSemigroup[Int](), "lastOptionSemigroup()"))
   include(SemigroupProperties(Semigroup.lastSemigroup[Int](), "lastSemigroup()"))

From aa4de33faacb59c7dd24092fe3d3a65ca3a4c4d9 Mon Sep 17 00:00:00 2001
From: Ryan Johnson <johnson.1922@osu.edu>
Date: Tue, 9 May 2017 22:47:43 -0500
Subject: [PATCH 178/336] Added working tests coverage for the StringBuffer and
 StringBuilder semigroup implementations.  Added the Semigroup tests to the
 list of Scalacheck test suite.

---
 .../src/test/scala/fj/CheckSemigroup.scala    | 33 ++++++++++++-------
 .../src/test/scala/fj/Tests.scala             | 30 +++++++++--------
 2 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
index 1305efe9..8c9fe547 100644
--- a/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
+++ b/props-core-scalacheck/src/test/scala/fj/CheckSemigroup.scala
@@ -70,27 +70,36 @@ object CheckIOSemigroup extends Properties("ioSemigroup") {
 
 }
 
-object CheckStringBuilder extends Properties("stringBuilderSemigroup") {
-
-  val s: Semigroup[java.lang.StringBuilder] = Semigroup.stringBuilderSemigroup
+/**
+  * A [[Properties]] implementation for testing [[Semigroup]] implementations that
+  * apply to mutable builder style classes such as [[java.lang.StringBuilder]] and
+  * [[java.lang.StringBuffer]].
+  *
+  * @param s          a Semigroup implementation to test.
+  * @param desc       a description of the Semigroup implementation under test.
+  * @param conversion a function that converts a value of type T to a new instance of type S.
+  * @tparam T the type that the builder constructs.
+  * @tparam S the type to which the Semigroup applies.
+  */
+case class CheckMutableBuilder[S, T](s: Semigroup[S], desc: String, conversion: T => S)(implicit val arbitrary: Arbitrary[T]) extends Properties(desc) {
 
-  implicit def toStringBuilder(str: String): java.lang.StringBuilder = new java.lang.StringBuilder(str)
+  implicit def toBuilder(t: T): S = conversion(t)
 
-  property("sum(x,y)") = forAll((x: String, y: String, z: String) =>
+  property("sum(x,y)") = forAll((x: T, y: T, z: T) =>
     s.sum(s.sum(x, y), z).toString == s.sum(x, s.sum(y, z)).toString
   )
 
-  property("sum()") = forAll((x: String, y: String, z: String) => {
+  property("sum()") = forAll((x: T, y: T, z: T) => {
     val sf = s.sum()
-    sf.f(sf.f(x).f(y)).f(z).toString == sf.f(x).f(sf.f(y).f(z.toString))
+    sf.f(sf.f(x).f(y)).f(z).toString == sf.f(x).f(sf.f(y).f(z)).toString
   })
 
-  property("dual()") = forAll((x: String, y: String, z: String) => {
+  property("dual()") = forAll((x: T, y: T, z: T) => {
     val sd = s.dual()
-    sd.sum(sd.sum(x, y), z).toString == sd.sum(x, sd.sum(y, z).toString)
+    sd.sum(sd.sum(x, y), z).toString == sd.sum(x, sd.sum(y, z)).toString
   })
 
-  property("sum(x)") = forAll((x: String, y: String) =>
+  property("sum(x)") = forAll((x: T, y: T) =>
     s.sum(x).f(y).toString == s.sum(x, y).toString)
 
 }
@@ -193,8 +202,8 @@ object CheckSemigroup extends Properties("Semigroup") {
   include(SemigroupProperties(Semigroup.streamSemigroup[Int](), "streamSemigroup"))
 
   include(SemigroupProperties(Semigroup.stringSemigroup, "stringSemigroup"))
-  include(SemigroupProperties(Semigroup.stringBufferSemigroup, "stringBufferSemigroup"))
-  include(SemigroupProperties(Semigroup.stringBuilderSemigroup, "stringBuilderSemigroup"))
+  include(CheckMutableBuilder(Semigroup.stringBufferSemigroup, "stringBufferSemigroup", (s: String) => new java.lang.StringBuffer(s)))
+  include(CheckMutableBuilder(Semigroup.stringBuilderSemigroup, "stringBuilderSemigroup", (s: String) => new java.lang.StringBuilder(s)))
 
 
   include(SemigroupProperties(Semigroup.unitSemigroup, "unitSemigroup"))
diff --git a/props-core-scalacheck/src/test/scala/fj/Tests.scala b/props-core-scalacheck/src/test/scala/fj/Tests.scala
index 60c2f009..d94661f9 100644
--- a/props-core-scalacheck/src/test/scala/fj/Tests.scala
+++ b/props-core-scalacheck/src/test/scala/fj/Tests.scala
@@ -1,8 +1,9 @@
 package fj
 
 object Tests {
-  def tests = List (
+  def tests = List(
     CheckP2.properties,
+    CheckSemigroup.properties,
     fj.data.CheckArray.properties,
     fj.data.CheckIO.properties,
     fj.data.CheckIteratee.properties,
@@ -19,26 +20,27 @@ object Tests {
 
   def main(args: Array[String]) {
     run(tests)
-//    System.exit(0)
+    //    System.exit(0)
   }
 
-  import org.scalacheck.Prop
-  import org.scalacheck.Test
   import org.scalacheck.Test.check
+  import org.scalacheck.{Prop, Test}
 
   def run(tests: List[(String, Prop)]) =
     tests foreach { case (name, p) => {
-        val c = check(new Test.Parameters.Default { override val maxSize = 20 }, p)
-        c.status match {
-          case Test.Passed => println("Passed " + name)
-          case Test.Proved(_) => println("Proved " + name)
-          case f @ Test.Failed(_, _) => sys.error(name + ": " + f)
-          case Test.Exhausted => println("Exhausted " + name)
-          case f @ Test.PropException(_, e, _) => {
-            e.printStackTrace
-            sys.error(name + ": " + f)
-          }
+      val c = check(new Test.Parameters.Default {
+        override val maxSize = 20
+      }, p)
+      c.status match {
+        case Test.Passed => println("Passed " + name)
+        case Test.Proved(_) => println("Proved " + name)
+        case f@Test.Failed(_, _) => sys.error(name + ": " + f)
+        case Test.Exhausted => println("Exhausted " + name)
+        case f@Test.PropException(_, e, _) => {
+          e.printStackTrace
+          sys.error(name + ": " + f)
         }
       }
     }
+    }
 }

From e834e8bfb87c394b0071e478a84445a1ca88834e Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb.giraudeau@lombardodier.com>
Date: Wed, 9 Aug 2017 13:34:53 +0200
Subject: [PATCH 179/336] Enable upload of snapshot artifacts.

---
 .travis.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 8f3091d1..4a9f2d24 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -30,3 +30,10 @@ script:
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)
+  - '[ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
+  && ./gradlew uploadArchives'
+
+env:
+  global:
+    - secure: Bun+1FZ29Q3dR9gZ/5brxcSf+zcY5tWrsqOA4GUb5bYCMyORuXQB0FYXuhKR4wB1pFrk1a9EYwRwSu3GwRJVWb+UzF0CNOWF/QG5tGPx32IOXScwlL/KonI4Vhs7Oc0fF4Wdb7euNrT27BU61jbUugjJ642b3n0VBYFYDdquprU=
+    - secure: QAxhjqLRa+WHKIzgIJPZ/rM5a5uzqG7E5rsC0YvB25cO712oYXmzsYPia/oSp0chXlYLYMfk2UnLeQCSx2e6ogXRRRa977Q+B33Nt0Hd9SGLtduv6DBrbA2ehLU12Ib4DWe5VhF5eueAunycYcllTvqA5h+pzTtEVbd68ZHncM4=

From 8330696120a4bcb744b1601600cb573dc176d0fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 9 Sep 2017 16:29:09 -0400
Subject: [PATCH 180/336] Upgrade Gradle version to 4.1
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 gradle/wrapper/gradle-wrapper.jar        | Bin 54208 -> 54708 bytes
 gradle/wrapper/gradle-wrapper.properties |   3 +--
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 2dcd00d1ccd90b5b3d39e0da139893d5e7651ae4..7a3265ee94c0ab25cf079ac8ccdf87f41d455d42 100644
GIT binary patch
delta 19176
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

delta 18758
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 7a57ac51..f16d2666 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,5 @@
-#Mon Mar 27 13:51:02 CEST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-bin.zip

From 95c0d0d659a2dfa354aa549aa6197be7d12aba15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 9 Sep 2017 17:38:22 -0400
Subject: [PATCH 181/336] Bring dependencies current
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle      | 2 +-
 core/build.gradle | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 04209664..6f8ecc5d 100644
--- a/build.gradle
+++ b/build.gradle
@@ -6,7 +6,7 @@ ext {
 
 buildscript {
     ext {
-		uptodateVersion = "1.6.2"
+        uptodateVersion = "1.6.3"
         retrolambdaPluginVersion = "3.5.0"
         retrolambdaVersion = "2.5.1"
     }
diff --git a/core/build.gradle b/core/build.gradle
index b3e1756e..e0c86f0c 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -7,8 +7,8 @@ archivesBaseName = project.projectName
 
 dependencies {
     testCompile dependencyJunit
-    testCompile 'com.h2database:h2:1.4.191'
-    testCompile 'commons-dbutils:commons-dbutils:1.6'
+    testCompile 'com.h2database:h2:1.4.196'
+    testCompile 'commons-dbutils:commons-dbutils:1.7'
 }
 
 performSigning(signingEnabled, signModule)

From 6c6dabdb26b050c5d0e3a712fe4f28edd0e1ad57 Mon Sep 17 00:00:00 2001
From: l1cache <cache@bk.ru>
Date: Mon, 11 Sep 2017 14:19:59 +0300
Subject: [PATCH 182/336] Equal: remove reference to static field of
 LazyString. Fix #321

  Cause it could cause deadlock on parallel static initialization.
---
 core/src/main/java/fj/Equal.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index b64c758d..5e407a00 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -674,7 +674,7 @@ public static <A> Equal<V8<A>> v8Equal(final Equal<A> ea) {
   /**
    * An equal instance for lazy strings.
    */
-  public static final Equal<LazyString> eq = streamEqual(charEqual).contramap(LazyString.toStream);
+  public static final Equal<LazyString> eq = streamEqual(charEqual).contramap(LazyString::toStream);
 
   /**
    * An equal instance for the empty heterogeneous list.

From 065ed439303eacf90e3ac49c5403b1d62979b8f4 Mon Sep 17 00:00:00 2001
From: janbols <guterfluss@gmail.com>
Date: Mon, 6 Nov 2017 20:09:10 +0100
Subject: [PATCH 183/336] Add append methods to all Px classes. Fix #326

---
 core/src/main/java/fj/P2.java | 63 ++++++++++++++++++++++++++++++++++-
 core/src/main/java/fj/P3.java | 52 +++++++++++++++++++++++++++++
 core/src/main/java/fj/P4.java | 44 ++++++++++++++++++++++++
 core/src/main/java/fj/P5.java | 30 +++++++++++++++++
 core/src/main/java/fj/P6.java | 20 +++++++++++
 core/src/main/java/fj/P7.java | 10 ++++++
 6 files changed, 218 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index e503ff40..b434a0da 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -178,7 +178,68 @@ public final P1<B> _2_() {
     return F1Functions.lazy(P2.<A, B>__2()).f(this);
   }
 
-    /**
+  /**
+   * Creates a {@link P3} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P3} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C> P3<A, B, C> append(C el) {
+    return P.p(_1(), _2(), el);
+  }
+
+  /**
+   * Creates a {@link P4} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P4} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D> P4<A, B, C, D> append(P2<C, D> el) {
+    return P.p(_1(), _2(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E> P5<A, B, C, D, E> append(P3<C, D, E> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F> P6<A, B, C, D, E, F> append(P4<C, D, E, F> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F, G> P7<A, B, C, D, E, F, G> append(P5<C, D, E, F, G> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4(), el._5());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P2}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P2} with the extra element added at the end
+   */
+  public final <C, D, E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P6<C, D, E, F, G, H> el) {
+    return P.p(_1(), _2(), el._1(), el._2(), el._3(), el._4(), el._5(), el._6());
+  }
+
+
+  /**
      * Provides a memoising P2 that remembers its values.
      *
      * @return A P2 that calls this P2 once for any given element and remembers the value for subsequent calls.
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index ec277346..fe980059 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -122,6 +122,58 @@ public final P1<C> _3_() {
     return F1Functions.lazy(P3.<A, B, C>__3()).f(this);
   }
 
+
+  /**
+   * Creates a {@link P4} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P4} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D> P4<A, B, C, D> append(D el) {
+    return P.p(_1(), _2(), _3(), el);
+  }
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E> P5<A, B, C, D, E> append(P2<D, E> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F> P6<A, B, C, D, E, F> append(P3<D, E, F> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F, G> P7<A, B, C, D, E, F, G> append(P4<D, E, F, G> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3(), el._4());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P3}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P3} with the extra element added at the end
+   */
+  public final <D, E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P5<D, E, F, G, H> el) {
+    return P.p(_1(), _2(), _3(), el._1(), el._2(), el._3(), el._4(), el._5());
+  }
+
+
   /**
    * Provides a memoising P3 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index 3f7236fe..a7bf8167 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -176,6 +176,50 @@ public final P1<D> _4_() {
     return F1Functions.lazy(P4.<A, B, C, D>__4()).f(this);
   }
 
+
+  /**
+   * Creates a {@link P5} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P5} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E> P5<A, B, C, D, E> append(E el) {
+    return P.p(_1(), _2(), _3(), _4(), el);
+  }
+
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F> P6<A, B, C, D, E, F> append(P2<E, F> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F, G> P7<A, B, C, D, E, F, G> append(P3<E, F, G> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2(), el._3());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P4}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P4} with the extra element added at the end
+   */
+  public final <E, F, G, H> P8<A, B, C, D, E, F, G, H> append(P4<E, F, G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), el._1(), el._2(), el._3(), el._4());
+  }
+
+
+
+
   /**
    * Provides a memoising P4 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 393b0632..69262327 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -238,6 +238,36 @@ public final P1<E> _5_() {
     return F1Functions.lazy(P5.<A, B, C, D, E>__5()).f(this);
   }
 
+  /**
+   * Creates a {@link P6} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P6} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F> P6<A, B, C, D, E, F> append(F el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el);
+  }
+
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F, G> P7<A, B, C, D, E, F, G> append(P2<F, G> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el._1(), el._2());
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P5}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P5} with the extra element added at the end
+   */
+  public final <F, G, H> P8<A, B, C, D, E, F, G, H> append(P3<F, G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), el._1(), el._2(), el._3());
+  }
+
   /**
    * Provides a memoising P5 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index 1e8c3055..fbf91948 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -309,6 +309,26 @@ public final P1<F> _6_() {
     return F1Functions.lazy(P6.<A, B, C, D, E, F>__6()).f(this);
   }
 
+  /**
+   * Creates a {@link P7} by adding the given element to the current {@link P6}
+   *
+   * @param el the element to append
+   * @return A {@link P7} containing the original {@link P6} with the extra element added at the end
+   */
+  public final <G> P7<A, B, C, D, E, F, G> append(G el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), el);
+  }
+
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P6}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P6} with the extra element added at the end
+   */
+  public final <G, H> P8<A, B, C, D, E, F, G, H> append(P2<G, H> el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), el._1(), el._2());
+  }
+
   /**
    * Provides a memoising P6 that remembers its values.
    *
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index ca24b40e..b1c67b30 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -387,6 +387,16 @@ public final P1<G> _7_() {
     return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__7()).f(this);
   }
 
+  /**
+   * Creates a {@link P8} by adding the given element to the current {@link P7}
+   *
+   * @param el the element to append
+   * @return A {@link P8} containing the original {@link P7} with the extra element added at the end
+   */
+  public final <H> P8<A, B, C, D, E, F, G, H> append(H el) {
+    return P.p(_1(), _2(), _3(), _4(), _5(), _6(), _7(), el);
+  }
+
   /**
    * Provides a memoising P7 that remembers its values.
    *

From 34f2c176ac462596f22de81a70fd0bfdda8f6ed9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 9 Sep 2017 17:44:31 -0400
Subject: [PATCH 184/336] Bring ScalaCheck current
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 props-core-scalacheck/build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index 02f3652a..a395a586 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -4,9 +4,9 @@ archivesBaseName = "${project.projectName}-${project.name}"
 apply plugin: 'scala'
 
 ext {
-    scalaVersion = "2.11.8"
+    scalaVersion = "2.11.11"
     scalacheckScalaVersion = "2.11"
-    scalacheckVersion = "1.12.5"
+    scalacheckVersion = "1.12.6"
     signModule = true
 }
 

From 98294fc3bdffe6c290818a6ffc04227e44ea3719 Mon Sep 17 00:00:00 2001
From: Iaroslav Zeigerman <zeigerman.ia@gmail.com>
Date: Wed, 17 Jan 2018 08:51:51 -0500
Subject: [PATCH 185/336] Introduce the Eval monad

a convenient wrapper around Trampoline and P1.hardMemo
for stack-safe computation.
---
 core/src/main/java/fj/data/Eval.java     | 238 +++++++++++++++++++++++
 core/src/test/java/fj/data/EvalTest.java |  76 ++++++++
 2 files changed, 314 insertions(+)
 create mode 100644 core/src/main/java/fj/data/Eval.java
 create mode 100644 core/src/test/java/fj/data/EvalTest.java

diff --git a/core/src/main/java/fj/data/Eval.java b/core/src/main/java/fj/data/Eval.java
new file mode 100644
index 00000000..519070a1
--- /dev/null
+++ b/core/src/main/java/fj/data/Eval.java
@@ -0,0 +1,238 @@
+package fj.data;
+
+import fj.F;
+import fj.F0;
+import fj.P;
+import fj.P1;
+import fj.control.Trampoline;
+
+/**
+ * <code>Eval</code> is an abstraction over different models of evaluation.
+ * The data constructors:
+ * <ul>
+ *   <li><code>Now</code> - the value is evaluated immediately.</li>
+ *   <li><code>Later</code> - the value is evaluated only once when it's requested (lazy evaluation).</li>
+ *   <li><code>Always</code> - the value is evaluated every time when it's requested.</li>
+ * </ul>
+ *
+ * Both <code>Later</code> and <code>Always</code> are lazy computations, while <code>Now</code> is eager.
+ *
+ *
+ * @version %build.number%
+ */
+public abstract class Eval<A> {
+
+  /**
+   * Constructs an eager evaluation by wrapping the given value.
+   *
+   * @param a the evaluated value.
+   * @return an eval with computed value.
+   */
+  public static <A> Eval<A> now(A a) {
+    return new Now<>(a);
+  }
+
+  /**
+   * Constructs a lazy evaluation with caching.
+   *
+   * @param a the supplier that evaluates a value.
+   * @return a lazy evaluation.
+   */
+  public static <A> Eval<A> later(F0<A> a) {
+    return new Later<>(a);
+  }
+
+  /**
+   * Constructs a lazy evaluation without caching.
+   *
+   * @param a the supplier that evaluates a value.
+   * @return a lazy evaluation.
+   */
+  public static <A> Eval<A> always(F0<A> a) {
+    return new Always<>(a);
+  }
+
+  /**
+   * Constructs a lazy evaluation of an expression that produces <code>Eval<A></code>.
+   * This operation is stack-safe and can be used for recursive computations.
+   *
+   * @param a the supplier that produces an <code>Eval<A></code>.
+   * @return a lazily evaluated nested evaluation.
+   */
+  public static <A> Eval<A> defer(F0<Eval<A>> a) {
+    return new DeferEval<>(a);
+  }
+
+  /**
+   * Evaluates the computation and return its result.
+   * Depending on whether the current instance is lazy or eager the
+   * computation may or may not happen at this point.
+   *
+   * @return a result of this computation.
+   */
+  public abstract A value();
+
+  /**
+   * Transforms <code>Eval<A></code> into a <code>Eval<B></code> using
+   * the given function.
+   *
+   * Note: the computation of the given transformation is always lazy,
+   * even if it invoked for an eager <code>Now</code> instance. This computation
+   * is performed in O(1) stack space.
+   *
+   * @param f the transformation function.
+   * @return a transformed evaluation.
+   */
+  public final <B> Eval<B> map(final F<A, B> f) {
+    return bind(a -> now(f.f(a)));
+  }
+
+  /**
+   * Alias for {@link #bind(F)}.
+   */
+  public final <B> Eval<B> flatMap(final F<A, Eval<B>> f) {
+    return bind(f);
+  }
+
+  /**
+   * Transforms <code>Eval<A></code> into a <code>Eval<B></code> using
+   * the given function that directly produces <code>Eval<B></code>.
+   *
+   * Note: the computation of the given transformation is always lazy,
+   * even if it invoked for an eager <code>Now</code> instance. This computation
+   * is performed in O(1) stack space.
+   *
+   * @param f the transformation function.
+   * @return a transformed evaluation.
+   */
+  public final <B> Eval<B> bind(final F<A, Eval<B>> f) {
+    return new BindTrampolineEval<>(f, asTrampoline());
+  }
+
+  /**
+   * Transforms the current instance into a trampoline instance.
+   */
+  abstract TrampolineEval<A> asTrampoline();
+
+  /**
+   * Represents an eager computation.
+   */
+  private static final class Now<A> extends Eval<A> {
+    private final A a;
+
+    Now(A a) {
+      this.a = a;
+    }
+
+    @Override
+    public final A value() {
+      return a;
+    }
+
+    @Override
+    final TrampolineEval<A> asTrampoline() {
+      return new PureTrampolineEval<>(this);
+    }
+  }
+
+  /**
+   * Represents a lazy computation that is evaluated only once.
+   */
+  private static final class Later<A> extends Eval<A> {
+    private final P1<A> memo;
+
+    Later(F0<A> producer) {
+      this.memo = P.hardMemo(producer);
+    }
+
+    @Override
+    public final A value() {
+      return memo._1();
+    }
+
+    @Override
+    final TrampolineEval<A> asTrampoline() {
+      return new PureTrampolineEval<>(this);
+    }
+  }
+
+  /**
+   * Represents a lazy computation that is evaluated every time when it's requested.
+   */
+  private static final class Always<A> extends Eval<A> {
+    private final F0<A> supplier;
+
+    Always(F0<A> supplier) {
+      this.supplier = supplier;
+    }
+
+    @Override
+    public final A value() {
+      return supplier.f();
+    }
+
+    @Override
+    final TrampolineEval<A> asTrampoline() {
+      return new PureTrampolineEval<>(this);
+    }
+  }
+
+  /**
+   * A helper abstraction that allows to perform recursive lazy transformations in O(1) stack space.
+   */
+  private static abstract class TrampolineEval<A> extends Eval<A> {
+
+    protected abstract Trampoline<A> trampoline();
+
+    @Override
+    public final A value() {
+      return trampoline().run();
+    }
+
+    @Override
+    final TrampolineEval<A> asTrampoline() {
+      return this;
+    }
+  }
+
+  private static final class PureTrampolineEval<A> extends TrampolineEval<A> {
+    private final Eval<A> start;
+
+    PureTrampolineEval(Eval<A> start) {
+      this.start = start;
+    }
+
+    @Override
+    protected final Trampoline<A> trampoline() {
+      return Trampoline.suspend(P.lazy(() -> Trampoline.pure(start.value())));
+    }
+  }
+
+  private static final class BindTrampolineEval<A, B> extends TrampolineEval<B> {
+    private final TrampolineEval<A> next;
+    private final F<A, Eval<B>> f;
+
+    BindTrampolineEval(F<A, Eval<B>> f, TrampolineEval<A> next) {
+      this.next = next;
+      this.f = f;
+    }
+
+    @Override
+    protected final Trampoline<B> trampoline() {
+      return Trampoline.suspend(P.lazy(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline())));
+    }
+  }
+
+  private static final class DeferEval<A> extends TrampolineEval<A> {
+    private final P1<Eval<A>> memo;
+
+    DeferEval(F0<Eval<A>> producer) {
+      this.memo = P.hardMemo(producer);
+    }
+
+    @Override
+    protected final Trampoline<A> trampoline() {
+      return memo._1().asTrampoline().trampoline();
+    }
+  }
+}
diff --git a/core/src/test/java/fj/data/EvalTest.java b/core/src/test/java/fj/data/EvalTest.java
new file mode 100644
index 00000000..a604c873
--- /dev/null
+++ b/core/src/test/java/fj/data/EvalTest.java
@@ -0,0 +1,76 @@
+package fj.data;
+
+import fj.F0;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EvalTest {
+
+  @Test
+  public void testNow() {
+    Eval<Integer> eval = Eval.now(1);
+    Assert.assertEquals(eval.value().intValue(), 1);
+    Assert.assertEquals(eval.map(a -> a.toString()).value(), "1");
+    Assert.assertEquals(eval.bind(a -> Eval.now(a * 3)).value().intValue(), 3);
+  }
+
+  @Test
+  public void testLater() {
+    InvocationTrackingF<Integer> tracker = new InvocationTrackingF<>(1);
+    Eval<Integer> eval = Eval.later(tracker);
+
+    Assert.assertEquals(tracker.getInvocationCounter(), 0);
+    Assert.assertEquals(eval.value().intValue(), 1);
+    Assert.assertEquals(tracker.getInvocationCounter(), 1);
+    eval.value();
+    Assert.assertEquals(tracker.getInvocationCounter(), 1);
+  }
+
+  @Test
+  public void testAlways() {
+    InvocationTrackingF<Integer> tracker = new InvocationTrackingF<>(1);
+    Eval<Integer> eval = Eval.always(tracker);
+
+    Assert.assertEquals(tracker.getInvocationCounter(), 0);
+    Assert.assertEquals(eval.value().intValue(), 1);
+    Assert.assertEquals(tracker.getInvocationCounter(), 1);
+    eval.value();
+    eval.value();
+    Assert.assertEquals(tracker.getInvocationCounter(), 3);
+  }
+
+  @Test
+  public void testDefer() {
+    // Make sure that a recursive computation is actually stack-safe.
+    Assert.assertEquals(even(200000).value(), "done");
+  }
+
+  private static Eval<String> even(int n) {
+    return Eval.now(n <= 0).flatMap(b -> b ? Eval.now("done") : Eval.defer(() -> odd(n - 1)));
+  }
+
+  private static Eval<String> odd(int n) {
+    return Eval.defer(() -> even(n - 1));
+  }
+
+  private static class InvocationTrackingF<A> implements F0<A> {
+
+    private final A value;
+    private int invocationCounter;
+
+    public InvocationTrackingF(A value) {
+      this.value = value;
+      this.invocationCounter = 0;
+    }
+
+    @Override
+    public A f() {
+      invocationCounter++;
+      return value;
+    }
+
+    public int getInvocationCounter() {
+      return invocationCounter;
+    }
+  }
+}

From e0f69dc368fe0df52531dc48c490a27ae143de2c Mon Sep 17 00:00:00 2001
From: Iaroslav Zeigerman <zeigerman.ia@gmail.com>
Date: Thu, 18 Jan 2018 10:25:18 -0500
Subject: [PATCH 186/336] Fix a recursive trampoline call in the Eval Defer
 implementation (#329)

---
 core/src/main/java/fj/data/Eval.java     |  2 +-
 core/src/test/java/fj/data/EvalTest.java | 21 ++++++++++++++-------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/data/Eval.java b/core/src/main/java/fj/data/Eval.java
index 519070a1..3e513075 100644
--- a/core/src/main/java/fj/data/Eval.java
+++ b/core/src/main/java/fj/data/Eval.java
@@ -232,7 +232,7 @@ private static final class DeferEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return memo._1().asTrampoline().trampoline();
+      return Trampoline.suspend(P.lazy(() -> memo._1().asTrampoline().trampoline()));
     }
   }
 }
diff --git a/core/src/test/java/fj/data/EvalTest.java b/core/src/test/java/fj/data/EvalTest.java
index a604c873..a3302e55 100644
--- a/core/src/test/java/fj/data/EvalTest.java
+++ b/core/src/test/java/fj/data/EvalTest.java
@@ -1,9 +1,12 @@
 package fj.data;
 
 import fj.F0;
+import fj.F2;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Iterator;
+
 public class EvalTest {
 
   @Test
@@ -42,15 +45,19 @@ public void testAlways() {
   @Test
   public void testDefer() {
     // Make sure that a recursive computation is actually stack-safe.
-    Assert.assertEquals(even(200000).value(), "done");
-  }
-
-  private static Eval<String> even(int n) {
-    return Eval.now(n <= 0).flatMap(b -> b ? Eval.now("done") : Eval.defer(() -> odd(n - 1)));
+    int targetValue = 200000;
+    Iterator<Integer> it = Enumerator.intEnumerator.toStream(0).iterator();
+    Eval<Boolean> result = foldRight(it, (v, acc) -> v == targetValue ? Eval.now(true) : acc, false);
+    Assert.assertTrue(result.value());
   }
 
-  private static Eval<String> odd(int n) {
-    return Eval.defer(() -> even(n - 1));
+  private static <A, T> Eval<A> foldRight(Iterator<T> iterator,
+                                          F2<T, Eval<A>, Eval<A>> f,
+                                          A zero) {
+    if (!iterator.hasNext()) {
+      return Eval.now(zero);
+    }
+    return f.f(iterator.next(), Eval.defer(() -> foldRight(iterator, f, zero)));
   }
 
   private static class InvocationTrackingF<A> implements F0<A> {

From 7a30ac7323670bb134b78e6ddbba4452b881af4f Mon Sep 17 00:00:00 2001
From: l1cache <cache@bk.ru>
Date: Fri, 2 Feb 2018 11:46:12 -0800
Subject: [PATCH 187/336] Added some useful functions to Equal

---
 core/src/main/java/fj/Equal.java     | 68 ++++++++++++++++++++++++++++
 core/src/test/java/fj/EqualTest.java | 48 ++++++++++++++++++++
 2 files changed, 116 insertions(+)
 create mode 100644 core/src/test/java/fj/EqualTest.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 5e407a00..07863acf 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -132,6 +132,74 @@ public boolean equal(B b1, B b2) {
     });
   }
 
+  /**
+   * Constructs an equal instance, which tests equality of self and the mapped object in "and" manner
+   *
+   * @param f The function to map the original object
+   * @param eq Equality for the mapped object
+   * @return A new equal instance
+   */
+  public final <B> Equal<A> andThen(final F<A, B> f, final Equal<B> eq) {
+    return and(eq.contramap(f));
+  }
+
+  /**
+   * An equal instance, which executes two Equality of self in "and" manner
+   *
+   * @param eq Another equality for self
+   * @return A new equal instance
+   */
+  public final Equal<A> and(final Equal<A> eq) {
+    return equalDef((a1, a2) -> def.equal(a1, a2) && eq.def.equal(a1, a2));
+  }
+
+  /**
+   * An equal instance, which executes two Equality of self in "or" manner
+   *
+   * @param eq Another equality for self
+   * @return A new equal instance
+   */
+  public final Equal<A> or(final Equal<A> eq) {
+    return equalDef((a1, a2) -> def.equal(a1, a2) || eq.def.equal(a1, a2));
+  }
+
+  /**
+   * An equal instance, which reverts equality for self
+   *
+   * @return A new equal instance
+   */
+  public final Equal<A> not() {
+    return equalDef((a1, a2) -> !def.equal(a1, a2));
+  }
+
+  /**
+   * Static version of {@link #contramap(F)}
+   */
+  public static <A, B> Equal<A> contramap(final F<A, B> f, final Equal<B> eq) {
+    return eq.contramap(f);
+  }
+
+  /**
+   * Static version of {@link #and(Equal)}
+   */
+  public static <A> Equal<A> and(final Equal<A> eq1, final Equal<A> eq2) {
+    return eq1.and(eq2);
+  }
+
+  /**
+   * Static version of {@link #or(Equal)}
+   */
+  public static <A> Equal<A> or(final Equal<A> eq1, final Equal<A> eq2) {
+    return eq1.or(eq2);
+  }
+
+  /**
+   * Static version of {@link #not()}
+   */
+  public static <A> Equal<A> not(final Equal<A> eq) {
+    return eq.not();
+  }
+
   /**
    * Constructs an equal instance from the given function.
    *
diff --git a/core/src/test/java/fj/EqualTest.java b/core/src/test/java/fj/EqualTest.java
new file mode 100644
index 00000000..776ccc57
--- /dev/null
+++ b/core/src/test/java/fj/EqualTest.java
@@ -0,0 +1,48 @@
+package fj;
+
+import org.junit.Test;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+
+public class EqualTest {
+  @Test
+  public void contramapShouldWork() {
+    Equal<String> equalByLength = Equal.contramap(String::length, Equal.intEqual);
+
+    assertThat(equalByLength.eq("str1", "str2"), is(true));
+    assertThat(equalByLength.eq("str1", "str11"), is(false));
+  }
+
+  @Test
+  public void andShouldWork() {
+    Equal<String> equalByLengthAndLastDigit = Equal.and(Equal.contramap(String::length, Equal.intEqual),
+                                                        Equal.contramap(s -> s.charAt(s.length() - 1),
+                                                                        Equal.charEqual));
+
+    assertThat(equalByLengthAndLastDigit.eq("str1", "spr1"), is(true));
+    assertThat(equalByLengthAndLastDigit.eq("str1", "str2"), is(false));
+    assertThat(equalByLengthAndLastDigit.eq("str1", "strr1"), is(false));
+  }
+
+  @Test
+  public void orShouldWork() {
+    Equal<String> equalByLengthOrLastDigit = Equal.or(Equal.contramap(String::length, Equal.intEqual),
+                                                      Equal.contramap(s -> s.charAt(s.length() - 1),
+                                                                      Equal.charEqual));
+
+    assertThat(equalByLengthOrLastDigit.eq("str1", "str2"), is(true));
+    assertThat(equalByLengthOrLastDigit.eq("str1", "strr1"), is(true));
+    assertThat(equalByLengthOrLastDigit.eq("str1", "strr2"), is(false));
+  }
+
+  @Test
+  public void thenShouldWork() {
+    Equal<String> equalByLengthThenLastDigit = Equal.contramap(String::length, Equal.intEqual)
+                                                    .andThen(s -> s.charAt(s.length() - 1), Equal.charEqual);
+
+    assertThat(equalByLengthThenLastDigit.eq("str1", "spr1"), is(true));
+    assertThat(equalByLengthThenLastDigit.eq("str1", "str2"), is(false));
+    assertThat(equalByLengthThenLastDigit.eq("str1", "strr1"), is(false));
+  }
+}

From dc0f405dc9ab62c97400ce0c88853027218fb211 Mon Sep 17 00:00:00 2001
From: l1cache <cache@bk.ru>
Date: Fri, 2 Feb 2018 13:17:49 -0800
Subject: [PATCH 188/336] few useful function added to Ord class as well

---
 core/src/main/java/fj/Ord.java     | 33 ++++++++++++++++++++++++++++++
 core/src/test/java/fj/OrdTest.java | 18 ++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index a3e55edc..0b532ed1 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -287,6 +287,39 @@ public final Ord<A> reverse() {
     return ordDef(def.dual());
   }
 
+  /**
+   * Constructs an ord instance, which compares using self and if objects are equal compares using <code>ord</code>
+   *
+   * @param ord Ord for subsequent comparison
+   * @return A new equal instance
+   */
+  public final Ord<A> andThen(final Ord<A> ord) {
+    return ordDef((a1, a2) -> {
+      final Ordering compareResult = compare(a1, a2);
+      if(compareResult == Ordering.EQ)
+        return ord.compare(a1, a2);
+      return compareResult;
+    });
+  }
+
+  /**
+   * Constructs an ord instance, which compares using self and if objects are equal compares the mapped objects
+   *
+   * @param f The function to map the original object
+   * @param ord Ord for the mapped object
+   * @return A new equal instance
+   */
+  public final <B> Ord<A> andThen(final F<A, B> f, final Ord<B> ord) {
+    return andThen(ord.contramap(f));
+  }
+
+  /**
+   * Static version of {@link #contramap(F)}
+   */
+  public static <A, B> Ord<A> contramap(final F<A, B> f, final Ord<B> ord) {
+    return ord.contramap(f);
+  }
+
   /**
    * Returns an order instance that uses the given equality test and ordering function.
    *
diff --git a/core/src/test/java/fj/OrdTest.java b/core/src/test/java/fj/OrdTest.java
index d218387a..1dfa6223 100644
--- a/core/src/test/java/fj/OrdTest.java
+++ b/core/src/test/java/fj/OrdTest.java
@@ -24,4 +24,22 @@ public void isLessThan() {
     assertThat(pred.f(1L), is(false));
     assertThat(pred.f(2L), is(false));
   }
+
+  @Test
+  public void contramapShouldWork() {
+    Ord<String> lengthOrd = Ord.contramap(String::length, Ord.intOrd);
+
+    assertThat(lengthOrd.compare("str", "rts"), is(Ordering.EQ));
+    assertThat(lengthOrd.compare("strlong", "str"), is(Ordering.GT));
+  }
+
+  @Test
+  public void andThenShouldWork() {
+    Ord<String> lengthThenLastDigitOrd = Ord.contramap(String::length, Ord.intOrd)
+                                            .andThen(s -> s.charAt(s.length() - 1), Ord.charOrd);
+
+    assertThat(lengthThenLastDigitOrd.compare("str", "dyr"), is(Ordering.EQ));
+    assertThat(lengthThenLastDigitOrd.compare("stt", "str"), is(Ordering.GT));
+    assertThat(lengthThenLastDigitOrd.compare("str", "strr"), is(Ordering.LT));
+  }
 }

From c4f1f6830a7f6cf66efdffb9436676361af2ff25 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Tue, 20 Mar 2018 13:55:23 +0100
Subject: [PATCH 189/336] Move fluent Equal/Ord construction api to the
 Definition interfaces.

 Also remove Equal.or and Equal.and as there is no precise use case.
---
 core/src/main/java/fj/Equal.java     | 111 +++++++++++++--------------
 core/src/main/java/fj/Ord.java       | 101 ++++++++++++++----------
 core/src/test/java/fj/EqualTest.java |  26 +------
 core/src/test/java/fj/OrdTest.java   |   6 +-
 4 files changed, 117 insertions(+), 127 deletions(-)

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 07863acf..f427849a 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -48,6 +48,39 @@ public interface Definition<A> {
     default boolean equal(A a1, A a2) {
       return equal(a1).f(a2);
     }
+
+    /**
+     * Refine this equal definition, to tests equality of self and the mapped object in "and" manner.
+     * @see #equal()
+     *
+     * @param f The function to map the original object
+     * @param eq Equality for the mapped object
+     * @return A new equal definition
+     */
+    default <B> Definition<A> then(final F<A, B> f, final Equal<B> eq) {
+      Definition<B> bEqDef = eq.def;
+      return new Definition<A>() {
+        @Override
+        public F<A, Boolean> equal(A a1) {
+          F<A, Boolean> fa = Definition.this.equal(a1);
+          F<B, Boolean> fb = bEqDef.equal(f.f(a1));
+          return a2 -> fa.f(a2) && fb.f(f.f(a2));
+        }
+
+        @Override
+        public boolean equal(A a1, A a2) {
+          return Definition.this.equal(a1, a2) && bEqDef.equal(f.f(a1), f.f(a2));
+        }
+      };
+    }
+
+    /**
+     * Build an equal instance from this definition.
+     * to be called after some successive {@link #then(F, Equal)} calls.
+     */
+    default Equal<A> equal() {
+      return equalDef(this);
+    }
   }
 
   /**
@@ -118,58 +151,31 @@ public F<A, Boolean> eq(final A a) {
    * @return A new equal.
    */
   public <B> Equal<B> contramap(final F<B, A> f) {
-    Definition<A> eaDef = def;
-    return equalDef(new Definition<B>(){
-      @Override
-      public F<B, Boolean> equal(B b) {
-        return compose(eaDef.equal(f.f(b)), f);
-      }
-
-      @Override
-      public boolean equal(B b1, B b2) {
-        return eaDef.equal(f.f(b1), f.f(b2));
-      }
-    });
+    return equalDef(contramapDef(f, def));
   }
 
   /**
-   * Constructs an equal instance, which tests equality of self and the mapped object in "and" manner
+   * An equal instance, which reverts equality for self
    *
-   * @param f The function to map the original object
-   * @param eq Equality for the mapped object
    * @return A new equal instance
    */
-  public final <B> Equal<A> andThen(final F<A, B> f, final Equal<B> eq) {
-    return and(eq.contramap(f));
+  public final Equal<A> not() {
+    return equalDef((a1, a2) -> !def.equal(a1, a2));
   }
 
-  /**
-   * An equal instance, which executes two Equality of self in "and" manner
-   *
-   * @param eq Another equality for self
-   * @return A new equal instance
-   */
-  public final Equal<A> and(final Equal<A> eq) {
-    return equalDef((a1, a2) -> def.equal(a1, a2) && eq.def.equal(a1, a2));
-  }
 
-  /**
-   * An equal instance, which executes two Equality of self in "or" manner
-   *
-   * @param eq Another equality for self
-   * @return A new equal instance
-   */
-  public final Equal<A> or(final Equal<A> eq) {
-    return equalDef((a1, a2) -> def.equal(a1, a2) || eq.def.equal(a1, a2));
-  }
+  private static <A, B> Definition<B> contramapDef(F<B, A> f, Definition<A> aEqDef) {
+    return new Definition<B>(){
+      @Override
+      public F<B, Boolean> equal(B b) {
+        return compose(aEqDef.equal(f.f(b)), f);
+      }
 
-  /**
-   * An equal instance, which reverts equality for self
-   *
-   * @return A new equal instance
-   */
-  public final Equal<A> not() {
-    return equalDef((a1, a2) -> !def.equal(a1, a2));
+      @Override
+      public boolean equal(B b1, B b2) {
+        return aEqDef.equal(f.f(b1), f.f(b2));
+      }
+    };
   }
 
   /**
@@ -180,24 +186,11 @@ public static <A, B> Equal<A> contramap(final F<A, B> f, final Equal<B> eq) {
   }
 
   /**
-   * Static version of {@link #and(Equal)}
-   */
-  public static <A> Equal<A> and(final Equal<A> eq1, final Equal<A> eq2) {
-    return eq1.and(eq2);
-  }
-
-  /**
-   * Static version of {@link #or(Equal)}
-   */
-  public static <A> Equal<A> or(final Equal<A> eq1, final Equal<A> eq2) {
-    return eq1.or(eq2);
-  }
-
-  /**
-   * Static version of {@link #not()}
+   * Begin definition of an equal instance.
+   * @see Definition#then(F, Equal)
    */
-  public static <A> Equal<A> not(final Equal<A> eq) {
-    return eq.not();
+  public static <A, B> Definition<A> on(final F<A, B> f, final Equal<B> eq) {
+    return contramapDef(f, eq.def);
   }
 
   /**
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 0b532ed1..0a778f4d 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -84,6 +84,42 @@ public Definition<A> dual() {
         }
       };
     }
+
+    /**
+     * Refine this ord definition:  compares using self and if objects are equal compares using given <code>Ord</code>.
+     * @see #ord()
+     *
+     * @param bOrd Ord for subsequent comparison
+     * @return A new ord definition.
+     */
+    default <B> Definition<A> then(final F<A, B> f, final Ord<B> bOrd) {
+      Definition<B> bOrdDef = bOrd.def;
+      return new Definition<A>() {
+        @Override
+        public F<A, Ordering> compare(A a1) {
+          F<A, Ordering> fa = Definition.this.compare(a1);
+          F<B, Ordering> fb = bOrdDef.compare(f.f(a1));
+          return a2 -> {
+            Ordering aOrdering = fa.f(a2);
+            return aOrdering != Ordering.EQ ? aOrdering : fb.f(f.f(a2));
+          };
+        }
+
+        @Override
+        public Ordering compare(A a1, A a2) {
+          Ordering aOrdering = Definition.this.compare(a1, a2);
+          return aOrdering != Ordering.EQ ? aOrdering : bOrdDef.compare(f.f(a1), f.f(a2));
+        }
+      };
+    }
+
+    /**
+     * Build an ord instance from this definition.
+     * to be called after some successive {@link #then(F, Ord)} calls.
+     */
+    default Ord<A> ord() {
+      return ordDef(this);
+    }
   }
 
   /**
@@ -160,18 +196,7 @@ public Equal<A> equal() {
    * @return A new ord.
    */
   public <B> Ord<B> contramap(final F<B, A> f) {
-    Definition<A> selfDef = def;
-    return ordDef(new Definition<B>() {
-      @Override
-      public F<B, Ordering> compare(B b) {
-        return compose(selfDef.compare(f.f(b)), f);
-      }
-
-      @Override
-      public Ordering compare(B b1, B b2) {
-        return selfDef.compare(f.f(b1), f.f(b2));
-      }
-    });
+    return ordDef(contramapDef(f, def));
   }
 
   /**
@@ -288,36 +313,32 @@ public final Ord<A> reverse() {
   }
 
   /**
-   * Constructs an ord instance, which compares using self and if objects are equal compares using <code>ord</code>
-   *
-   * @param ord Ord for subsequent comparison
-   * @return A new equal instance
+   * Begin definition of an ord instance.
+   * @see Definition#then(F, Equal)
    */
-  public final Ord<A> andThen(final Ord<A> ord) {
-    return ordDef((a1, a2) -> {
-      final Ordering compareResult = compare(a1, a2);
-      if(compareResult == Ordering.EQ)
-        return ord.compare(a1, a2);
-      return compareResult;
-    });
-  }
-
-  /**
-   * Constructs an ord instance, which compares using self and if objects are equal compares the mapped objects
-   *
-   * @param f The function to map the original object
-   * @param ord Ord for the mapped object
-   * @return A new equal instance
-   */
-  public final <B> Ord<A> andThen(final F<A, B> f, final Ord<B> ord) {
-    return andThen(ord.contramap(f));
+  public static <A, B> Definition<A> on(final F<A, B> f, final Ord<B> ord) {
+    return contramapDef(f, ord.def);
   }
 
   /**
    * Static version of {@link #contramap(F)}
    */
   public static <A, B> Ord<A> contramap(final F<A, B> f, final Ord<B> ord) {
-    return ord.contramap(f);
+    return ordDef(contramapDef(f, ord.def));
+  }
+
+  private static <A, B> Definition<B> contramapDef(F<B, A> f, Definition<A> def) {
+    return new Definition<B>() {
+      @Override
+      public F<B, Ordering> compare(B b) {
+        return compose(def.compare(f.f(b)), f);
+      }
+
+      @Override
+      public Ordering compare(B b1, B b2) {
+        return def.compare(f.f(b1), f.f(b2));
+      }
+    };
   }
 
   /**
@@ -609,15 +630,15 @@ public static <A> Ord<P1<A>> p1Ord(final Ord<A> oa) {
    * @return An order instance for a product-2, with the first factor considered most significant.
    */
   public static <A, B> Ord<P2<A, B>> p2Ord(final Ord<A> oa, final Ord<B> ob) {
-    return ordDef((a, b) -> oa.eq(a._1(), b._1()) ? ob.compare(a._2(), b._2()) : oa.compare(a._1(), b._1()));
+    return on(P2.<A, B>__1(), oa).then(P2.__2(), ob).ord();
   }
 
     public static <A, B> Ord<P2<A, B>> p2Ord1(Ord<A> oa) {
-        return ordDef((p1, p2) -> oa.compare(p1._1(), p2._1()));
+        return on(P2.<A, B>__1(), oa).ord();
     }
 
     public static <A, B> Ord<P2<A, B>> p2Ord2(Ord<B> ob) {
-        return ordDef((p1, p2) -> ob.compare(p1._2(), p2._2()));
+        return on(P2.<A, B>__2(), ob).ord();
     }
 
   /**
@@ -629,9 +650,7 @@ public static <A, B> Ord<P2<A, B>> p2Ord2(Ord<B> ob) {
    * @return An order instance for a product-3, with the first factor considered most significant.
    */
   public static <A, B, C> Ord<P3<A, B, C>> p3Ord(final Ord<A> oa, final Ord<B> ob, final Ord<C> oc) {
-    return ordDef((a, b) -> oa.eq(a._1(), b._1()) ?
-           p2Ord(ob, oc).compare(P.p(a._2(), a._3()), P.p(b._2(), b._3()))
-                                 : oa.compare(a._1(), b._1()));
+    return on(P3.<A, B, C>__1(), oa).then(P3.__2(), ob).then(P3.__3(), oc).ord();
   }
 
   /**
diff --git a/core/src/test/java/fj/EqualTest.java b/core/src/test/java/fj/EqualTest.java
index 776ccc57..bacecc46 100644
--- a/core/src/test/java/fj/EqualTest.java
+++ b/core/src/test/java/fj/EqualTest.java
@@ -14,32 +14,10 @@ public void contramapShouldWork() {
     assertThat(equalByLength.eq("str1", "str11"), is(false));
   }
 
-  @Test
-  public void andShouldWork() {
-    Equal<String> equalByLengthAndLastDigit = Equal.and(Equal.contramap(String::length, Equal.intEqual),
-                                                        Equal.contramap(s -> s.charAt(s.length() - 1),
-                                                                        Equal.charEqual));
-
-    assertThat(equalByLengthAndLastDigit.eq("str1", "spr1"), is(true));
-    assertThat(equalByLengthAndLastDigit.eq("str1", "str2"), is(false));
-    assertThat(equalByLengthAndLastDigit.eq("str1", "strr1"), is(false));
-  }
-
-  @Test
-  public void orShouldWork() {
-    Equal<String> equalByLengthOrLastDigit = Equal.or(Equal.contramap(String::length, Equal.intEqual),
-                                                      Equal.contramap(s -> s.charAt(s.length() - 1),
-                                                                      Equal.charEqual));
-
-    assertThat(equalByLengthOrLastDigit.eq("str1", "str2"), is(true));
-    assertThat(equalByLengthOrLastDigit.eq("str1", "strr1"), is(true));
-    assertThat(equalByLengthOrLastDigit.eq("str1", "strr2"), is(false));
-  }
-
   @Test
   public void thenShouldWork() {
-    Equal<String> equalByLengthThenLastDigit = Equal.contramap(String::length, Equal.intEqual)
-                                                    .andThen(s -> s.charAt(s.length() - 1), Equal.charEqual);
+    Equal<String> equalByLengthThenLastDigit = Equal.on(String::length, Equal.intEqual)
+                                                    .then(s -> s.charAt(s.length() - 1), Equal.charEqual).equal();
 
     assertThat(equalByLengthThenLastDigit.eq("str1", "spr1"), is(true));
     assertThat(equalByLengthThenLastDigit.eq("str1", "str2"), is(false));
diff --git a/core/src/test/java/fj/OrdTest.java b/core/src/test/java/fj/OrdTest.java
index 1dfa6223..4addec65 100644
--- a/core/src/test/java/fj/OrdTest.java
+++ b/core/src/test/java/fj/OrdTest.java
@@ -34,9 +34,9 @@ public void contramapShouldWork() {
   }
 
   @Test
-  public void andThenShouldWork() {
-    Ord<String> lengthThenLastDigitOrd = Ord.contramap(String::length, Ord.intOrd)
-                                            .andThen(s -> s.charAt(s.length() - 1), Ord.charOrd);
+  public void thenShouldWork() {
+    Ord<String> lengthThenLastDigitOrd = Ord.on(String::length, Ord.intOrd)
+                                            .then(s -> s.charAt(s.length() - 1), Ord.charOrd).ord();
 
     assertThat(lengthThenLastDigitOrd.compare("str", "dyr"), is(Ordering.EQ));
     assertThat(lengthThenLastDigitOrd.compare("stt", "str"), is(Ordering.GT));

From bbc28c47a29d04724007192100edef79499078cc Mon Sep 17 00:00:00 2001
From: Sidney Quitorio <sidneyquitorio8@yahoo.com>
Date: Tue, 3 Jul 2018 16:16:17 -0700
Subject: [PATCH 190/336] Fixes exception in Either.LeftProjection.traverseIO

---
 core/src/main/java/fj/data/Either.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index 7d8e0bb7..a9a746a9 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -316,7 +316,7 @@ public <C> List<Either<C, B>> traverseList(final F<A, List<C>> f) {
        * @return An either after traversing through this projection.
        */
       public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
-          return e.isRight() ?
+          return e.isLeft() ?
                   IOFunctions.map(f.f(value()), Either::<C, B>left) :
                   IOFunctions.unit(Either.right(e.right().value()));
       }

From 8ff163c6bbcaf4888bde7dcef21a16137b4db5c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Wed, 11 Jul 2018 21:24:12 -0400
Subject: [PATCH 191/336] Bring Gradle to 4.8.1

---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 gradlew                                  | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index f16d2666..717f0389 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-bin.zip
diff --git a/gradlew b/gradlew
index 4453ccea..cccdd3d5 100755
--- a/gradlew
+++ b/gradlew
@@ -33,11 +33,11 @@ DEFAULT_JVM_OPTS=""
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
-warn ( ) {
+warn () {
     echo "$*"
 }
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
@@ -155,7 +155,7 @@ if $cygwin ; then
 fi
 
 # Escape application args
-save ( ) {
+save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }

From 4b6536110719689dad7e784ac389db05a0959af0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Wed, 11 Jul 2018 21:43:15 -0400
Subject: [PATCH 192/336] Bring dependencies current
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle      | 2 +-
 core/build.gradle | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 6f8ecc5d..e1fed096 100644
--- a/build.gradle
+++ b/build.gradle
@@ -72,7 +72,7 @@ allprojects {
         sonatypeUploadUrl = isSnapshot ? sonatypeSnapshotUrl : sonatypeReleaseUrl
         primaryEmail = "functionaljava@googlegroups.com"
 
-        dependencyJunit = "junit:junit:4.12"
+        dependencyJunit = "org.junit.vintage:junit-vintage-engine:5.2.0"
 
         displayCompilerWarnings = true
 
diff --git a/core/build.gradle b/core/build.gradle
index e0c86f0c..71dae913 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -7,7 +7,7 @@ archivesBaseName = project.projectName
 
 dependencies {
     testCompile dependencyJunit
-    testCompile 'com.h2database:h2:1.4.196'
+    testCompile 'com.h2database:h2:1.4.197'
     testCompile 'commons-dbutils:commons-dbutils:1.7'
 }
 

From 7576f6f65537cbb7f059d683d96425860b306213 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 21 Jul 2018 09:21:05 +0200
Subject: [PATCH 193/336] use openjdk7, remove oracle installer, try sudo false

---
 .travis.yml | 25 ++++---------------------
 1 file changed, 4 insertions(+), 21 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 4a9f2d24..539e7a45 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,30 +1,13 @@
-language: java
+# Use faster, Docker-based container (instead of OpenVZ)
+sudo: false
 
-sudo: required
+language: java
 
 jdk:
   - oraclejdk8
 
-addons:
-  apt:
-    packages:
-      - oracle-java8-installer
-
-before_script:
-  - sudo service postgresql stop || true
-  - sudo service mysql stop || true
-  - sudo service memcached stop || true
-  - sudo service bootlogd stop || true
-  - sudo service elasticsearch stop || true
-  - sudo service mongodb stop || true
-  - sudo service neo4j stop || true
-  - sudo service cassandra stop || true
-  - sudo service riak stop || true
-  - sudo service rsync stop || true
-  - sudo service x11-common stop || true
-
 script:
-  - jdk_switcher use oraclejdk7 && export JAVA7_HOME=$JAVA_HOME
+  - jdk_switcher use openjdk7 && export JAVA7_HOME=$JAVA_HOME
   - jdk_switcher use oraclejdk8 && export JAVA8_HOME=$JAVA_HOME
   - ./gradlew build coverage -s -i
 

From b280c531debd92885ca6b7998cb2aa485a0fd955 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Thu, 26 Jul 2018 18:48:45 -0400
Subject: [PATCH 194/336] Add IOFunctions tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/IOTest.java             | 30 --------
 .../test/java/fj/data/IOFunctionsTest.java    | 69 +++++++++++++++++--
 2 files changed, 63 insertions(+), 36 deletions(-)
 delete mode 100644 core/src/test/java/fj/IOTest.java

diff --git a/core/src/test/java/fj/IOTest.java b/core/src/test/java/fj/IOTest.java
deleted file mode 100644
index f965204c..00000000
--- a/core/src/test/java/fj/IOTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package fj;
-
-import fj.data.IO;
-import fj.data.IOFunctions;
-import org.junit.Test;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.StringReader;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-
-public class IOTest {
-
-    @Test
-    public void testLift() throws IOException {
-        final IO<String> readName = () -> new BufferedReader(new StringReader("foo")).readLine();
-        final F<String, IO<String>> upperCaseAndPrint = F1Functions.<String, IO<String>, String>o(this::println).f(String::toUpperCase);
-        final IO<String> readAndPrintUpperCasedName = IOFunctions.bind(readName, upperCaseAndPrint);
-        assertThat(readAndPrintUpperCasedName.run(), is("FOO"));
-    }
-
-    public IO<String> println(final String s) {
-        return () -> {
-            return s;
-        };
-    }
-}
diff --git a/core/src/test/java/fj/data/IOFunctionsTest.java b/core/src/test/java/fj/data/IOFunctionsTest.java
index dcafc221..b943db36 100644
--- a/core/src/test/java/fj/data/IOFunctionsTest.java
+++ b/core/src/test/java/fj/data/IOFunctionsTest.java
@@ -1,7 +1,6 @@
 package fj.data;
 
-import fj.Unit;
-import org.hamcrest.core.Is;
+import fj.*;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -9,6 +8,10 @@
 import java.io.Reader;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import static fj.data.IOFunctions.*;
+import static fj.data.Stream.cons;
+import static fj.data.Stream.nil_;
+import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.*;
 
 public class IOFunctionsTest {
@@ -30,8 +33,8 @@ public void close() {
         r -> () -> new BufferedReader(r).readLine()
     );
 
-    Assert.assertThat(bracketed.run(), Is.is("Read OK"));
-    Assert.assertThat(closed.get(), Is.is(true));
+    Assert.assertThat(bracketed.run(), is("Read OK"));
+    Assert.assertThat(closed.get(), is(true));
   }
 
   @Test
@@ -56,9 +59,63 @@ public void close() {
       bracketed.run();
       fail("Exception expected");
     } catch (IllegalArgumentException e) {
-      Assert.assertThat(e.getMessage(), Is.is("OoO"));
+      Assert.assertThat(e.getMessage(), is("OoO"));
     }
-    Assert.assertThat(closed.get(), Is.is(true));
+    Assert.assertThat(closed.get(), is(true));
+  }
+
+  @Test
+  public void testTraverseIO() throws IOException {
+    String[] as = {"foo1", "bar2", "foobar3"};
+    Stream<String> stream = Stream.arrayStream(as);
+    ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+    PrintStream originalOut = System.out;
+    System.setOut(new PrintStream(outContent));
+    stream.traverseIO(IOFunctions::stdoutPrint).run();
+    System.setOut(originalOut);
+    assertThat(outContent.toString(), is("foobar3bar2foo1"));
+  }
+
+  @Test
+  public void testSequenceWhile() throws IOException {
+    BufferedReader r = new BufferedReader(new StringReader("foo1\nbar2\nfoobar3"));
+    Stream<IO<String>> s1 = Stream.repeat(() -> r.readLine());
+    IO<Stream<String>> io = sequenceWhile(s1, s -> !s.equals("foobar3"));
+    assertThat(io.run(), is(cons("foo1", () -> cons("bar2", () -> Stream.nil()))));
+  }
+
+  @Test
+  public void testForeach() throws IOException {
+    Stream<IO<String>> s1 = Stream.repeat(() -> "foo1");
+    IO<Stream<String>> io = sequence(s1.take(2));
+    ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+    PrintStream originalOut = System.out;
+    System.setOut(new PrintStream(outContent));
+    runSafe(io).foreach(s -> runSafe(stdoutPrint(s)));
+    System.setOut(originalOut);
+    assertThat(outContent.toString(), is("foo1foo1"));
+  }
+
+
+  @Test
+  public void testReplicateM() throws IOException {
+    final IO<String> is = () -> new BufferedReader(new StringReader("foo")).readLine();
+    assertThat(replicateM(is, 3).run(), is(List.list("foo", "foo", "foo")));
+  }
+
+
+  @Test
+  public void testLift() throws IOException {
+    final IO<String> readName = () -> new BufferedReader(new StringReader("foo")).readLine();
+    final F<String, IO<String>> upperCaseAndPrint = F1Functions.<String, IO<String>, String>o(this::println).f(String::toUpperCase);
+    final IO<String> readAndPrintUpperCasedName = IOFunctions.bind(readName, upperCaseAndPrint);
+    assertThat(readAndPrintUpperCasedName.run(), is("FOO"));
+  }
+
+  private IO<String> println(final String s) {
+    return () -> {
+      return s;
+    };
   }
 
 }
\ No newline at end of file

From be646621a7be6dc7dfe5a10bb9fd26fd3d04c6e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 29 Jul 2018 08:47:35 -0400
Subject: [PATCH 195/336] Add Stream tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/data/StreamTest.java | 75 ++++++++++++++++++++--
 1 file changed, 69 insertions(+), 6 deletions(-)

diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index a37764c2..49840b78 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -1,16 +1,16 @@
 package fj.data;
 
+import fj.Equal;
+import fj.Ord;
+import fj.P2;
+import fj.control.parallel.Strategy;
 import org.junit.Test;
 
-import java.io.IOException;
-import java.util.ArrayList;
 import java.util.ConcurrentModificationException;
 
-import static fj.data.IOFunctions.stdinReadLine;
-import static java.lang.System.out;
+import static fj.data.Stream.*;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
 /**
@@ -21,7 +21,7 @@ public class StreamTest {
   @Test
   public void infiniteStream() {
     Stream<Integer> s = Stream.forever(Enumerator.intEnumerator, 0).bind(Stream::single);
-    assertEquals(List.range(0, 5), s.take(5).toList());
+    assertThat(List.range(0, 5), is(s.take(5).toList()));
   }
 
   @Test
@@ -48,5 +48,68 @@ public void iterableStreamWithStructureUpdate() {
         x = s2.head();
     }
 
+    @Test(expected=Error.class)
+    public void testCycleNil(){
+        cycle(Stream.nil());
+    }
+
+    @Test
+    public void testCycle() {
+        Stream<Character> s = stream(new Character[]{'a', 'b'});
+        assertThat(cycle(s).take(5),
+                is(stream(new Character[]{'a', 'b', 'a', 'b', 'a'})));
+    }
+
+    @Test
+    public void testIterate() {
+        assertThat(iterate(a -> 2 * a + 1, 1).take(5),
+                is(stream(new Integer[]{1, 3, 7, 15, 31})));
+    }
+
+    @Test
+    public void testArrayStreamEmpty() {
+        assertThat(arrayStream(new Integer[]{}), is(Stream.nil()));
+    }
+
+    @Test(expected=Error.class)
+    public void testNilHead() {
+        Stream.nil().head();
+    }
 
+    @Test(expected=Error.class)
+    public void testNilTail() {
+        Stream.nil().tail();
+    }
+
+    @Test
+    public void testArray() {
+        Character[] a = new Character[]{'a', 'b', 'c'};
+        Stream<Character> s = stream(a);
+        assertThat(s.array(Character[].class), is(a));
+    }
+
+    @Test
+    public void testZipIndex() {
+        Character[] a = new Character[]{'a', 'b', 'c'};
+        P2<Stream<Character>, Stream<Integer>> p = unzip(stream(a).zipIndex().drop(1));
+        assertThat(p._1(), is(stream(new Character[]{'b', 'c'})));
+        assertThat(p._2(), is(stream(new Integer[]{1, 2})));
+    }
+
+    @Test
+    public void testMinus() {
+        Character[] a1 = new Character[]{'a', 'b', 'c', 'd', 'e'};
+        Stream<Character> s1 = stream(a1);
+        Character[] a2 = new Character[]{'b', 'e'};
+        Stream<Character> s2 = stream(a2);
+        assertThat(s1.minus(Equal.charEqual, s2),
+                is(stream(new Character[]{'a', 'c', 'd'})));
+    }
+
+    @Test
+    public void testSort() {
+        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, Strategy.seqStrategy()),
+                is(s.sort(Ord.intOrd)));
+    }
 }

From 99a7642a5fbae7e90e5ce80bbe44842acc8f524b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 29 Jul 2018 21:20:43 +0200
Subject: [PATCH 196/336] Update to latest retrolambda

---
 build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index e1fed096..08d3e946 100644
--- a/build.gradle
+++ b/build.gradle
@@ -7,8 +7,8 @@ ext {
 buildscript {
     ext {
         uptodateVersion = "1.6.3"
-        retrolambdaPluginVersion = "3.5.0"
-        retrolambdaVersion = "2.5.1"
+        retrolambdaPluginVersion = "3.7.0"
+        retrolambdaVersion = "2.5.4"
     }
 
     repositories {

From 3fc4ab2994d942c121d79be37bda672e9a2a8262 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 29 Jul 2018 17:01:47 -0400
Subject: [PATCH 197/336] Exclude paths in codecov.io
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 codecov.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 codecov.yml

diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 00000000..8c7fd5e4
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,3 @@
+ignore:
+  - "demo/.*"
+  - "performance/.*"
\ No newline at end of file

From fa322e27df3c491d2e771a540894f9073d95f6eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 30 Jul 2018 15:45:03 -0400
Subject: [PATCH 198/336] Bring Gradle Jacoco current
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index e1fed096..1cc8078e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -38,8 +38,7 @@ allprojects {
 
 
     jacoco {
-//        toolVersion = "0.7.1.201405082137"
-        toolVersion = "0.7.6.201602180812"
+        toolVersion = "0.8.1"
 
     }
 

From e9fd4eca665bf392c6b1a72176e476ff6bae1289 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 30 Jul 2018 15:22:45 -0400
Subject: [PATCH 199/336] Add tests for Try, F, FW, Digit
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/F8Functions.java      |  1 -
 core/src/test/java/fj/DigitTest.java        | 30 ++++++++
 core/src/test/java/fj/FFunctionsTest.java   | 25 +++++++
 core/src/test/java/fj/FWFunctionsTest.java  | 24 ++++++
 core/src/test/java/fj/ShowTest.java         |  6 --
 core/src/test/java/fj/TryEffectTest.java    | 82 +++++++++++++++++++++
 core/src/test/java/fj/TryTest.java          | 50 +++++++++++++
 core/src/test/java/fj/data/JavaTest.java    |  4 +-
 core/src/test/java/fj/data/OptionTest.java  |  1 -
 core/src/test/java/fj/data/SeqTest.java     |  5 +-
 core/src/test/java/fj/data/StreamTest.java  |  9 ++-
 core/src/test/java/fj/data/TreeMapTest.java | 11 ---
 12 files changed, 226 insertions(+), 22 deletions(-)
 create mode 100644 core/src/test/java/fj/DigitTest.java
 create mode 100644 core/src/test/java/fj/FFunctionsTest.java
 create mode 100644 core/src/test/java/fj/FWFunctionsTest.java
 create mode 100644 core/src/test/java/fj/TryEffectTest.java
 create mode 100644 core/src/test/java/fj/TryTest.java

diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
index 071cb6bc..8b9883a3 100644
--- a/core/src/main/java/fj/F8Functions.java
+++ b/core/src/main/java/fj/F8Functions.java
@@ -11,7 +11,6 @@ private F8Functions() {
 	/**
 	 * Partial application.
 	 *
-	 * @param a The <code>A</code> to which to apply this function.
 	 * @return The function partially applied to the given argument.
 	 */
 	public static <A, B, C, D, E, F$, G, H, I> F7<B, C, D, E, F$, G, H, I> f(final F8<A, B, C, D, E, F$, G, H, I> func, final A a) {
diff --git a/core/src/test/java/fj/DigitTest.java b/core/src/test/java/fj/DigitTest.java
new file mode 100644
index 00000000..9fc98d4c
--- /dev/null
+++ b/core/src/test/java/fj/DigitTest.java
@@ -0,0 +1,30 @@
+package fj;
+
+import fj.data.Option;
+import org.junit.Test;
+
+import static fj.data.Array.range;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class DigitTest {
+    @Test
+    public void testInteger() {
+        for (Integer i: range(0, 10)) {
+            assertThat(Digit.fromLong(i).toLong(), is(i.longValue()));
+        }
+    }
+
+    @Test
+    public void testChar() {
+        for (Integer i: range(0, 10)) {
+            Character c = Character.forDigit(i, 10);
+            assertThat(Digit.fromChar(c).some().toChar(), is(c));
+        }
+    }
+
+    @Test
+    public void testCharNone() {
+        assertThat(Digit.fromChar('x'), is(Option.none()));
+    }
+}
diff --git a/core/src/test/java/fj/FFunctionsTest.java b/core/src/test/java/fj/FFunctionsTest.java
new file mode 100644
index 00000000..9d38e1f5
--- /dev/null
+++ b/core/src/test/java/fj/FFunctionsTest.java
@@ -0,0 +1,25 @@
+package fj;
+
+import org.junit.Test;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class FFunctionsTest {
+    @Test
+    public void testApply() {
+        F8<Integer, Integer, Integer, Integer,
+                Integer, Integer, Integer, Integer, Integer> f8 =
+                (i1, i2, i3, i4, i5, i6, i7, i8) ->
+                        i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
+        F7<Integer, Integer, Integer, Integer,
+                Integer, Integer, Integer, Integer> f7 = F8Functions.f(f8, 8);
+        F6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> f6 =
+                F7Functions.f(f7, 7);
+        F5<Integer, Integer, Integer, Integer, Integer, Integer> f5 = F6Functions.f(f6, 6);
+        F4<Integer, Integer, Integer, Integer, Integer> f4 = F5Functions.f(f5, 5);
+        F3<Integer, Integer, Integer, Integer> f3 = F4Functions.f(f4, 4);
+        F2<Integer, Integer, Integer> f2 = F3Functions.f(f3, 3);
+        F<Integer, Integer> f1 = F2Functions.f(f2, 2);
+        assertThat(F1Functions.f(f1, 1).f(), is(36));
+    }
+}
diff --git a/core/src/test/java/fj/FWFunctionsTest.java b/core/src/test/java/fj/FWFunctionsTest.java
new file mode 100644
index 00000000..b9ce65d5
--- /dev/null
+++ b/core/src/test/java/fj/FWFunctionsTest.java
@@ -0,0 +1,24 @@
+package fj;
+
+import org.junit.Test;
+
+import fj.F1W;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class FWFunctionsTest {
+    @Test
+    public void testLift1() {
+        F<Integer, Integer> f = i -> i + 1;
+        F1W f1w = F1W.lift(f);
+        assertThat(f1w.f(1), is(2));
+    }
+
+    @Test
+    public void testLift2() {
+        F2<Integer, Integer, Integer> f2 = (i, j) -> i + j;
+        F2W f2w = F2W.lift(f2);
+        assertThat(f2w.f(1, 2), is(3));
+    }
+
+}
diff --git a/core/src/test/java/fj/ShowTest.java b/core/src/test/java/fj/ShowTest.java
index e271f5a1..c516c0df 100644
--- a/core/src/test/java/fj/ShowTest.java
+++ b/core/src/test/java/fj/ShowTest.java
@@ -10,16 +10,10 @@
  * Created by MarkPerry on 4/06/2015.
  */
 public class ShowTest {
-
-
-
     @Test
     public void arrayShow() {
         Array<Integer> a = array(3, 5, 7);
         String s = Show.arrayShow(Show.intShow).showS(a);
-        System.out.println(s);
         assertTrue(s.equals("Array(3,5,7)"));
-
     }
-
 }
diff --git a/core/src/test/java/fj/TryEffectTest.java b/core/src/test/java/fj/TryEffectTest.java
new file mode 100644
index 00000000..bb684fc6
--- /dev/null
+++ b/core/src/test/java/fj/TryEffectTest.java
@@ -0,0 +1,82 @@
+package fj;
+
+import fj.data.Validation;
+import fj.function.TryEffect0;
+import fj.function.TryEffect1;
+import org.junit.Test;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class TryEffectTest {
+
+    @Test
+    public void testTryEffect0Success() {
+        F<TryEffect0, Validation<TryEffectException, Unit>> f =
+                TryEffect.f(TryEffect0<TryEffectException>::f);
+        Validation<TryEffectException, Unit> v = f.f(new AlwaysSucceed0());
+        assertThat(v.isSuccess(), is(true));
+        assertThat(v.success(), is(Unit.unit()));
+    }
+
+    @Test
+    public void testTryEffect0Fail() {
+        F<TryEffect0, Validation<TryEffectException, Unit>> f =
+                TryEffect.f(TryEffect0<TryEffectException>::f);
+        Validation<TryEffectException, Unit> v = f.f(new AlwaysFail0());
+        assertThat(v.isFail(), is(true));
+        assertThat(v.fail(), is(new TryEffectException()));
+    }
+
+    @Test
+    public void testTryEffect1Success() {
+        F2<TryEffect1<Integer, TryEffectException>, Integer, Validation<TryEffectException, Unit>> f =
+                TryEffect.f(TryEffect1<Integer, TryEffectException>::f);
+        Validation<TryEffectException, Unit> v = f.f(new AlwaysSucceed1(), 1);
+        assertThat(v.isSuccess(), is(true));
+        assertThat(v.success(), is(Unit.unit()));
+    }
+
+    @Test
+    public void testTryEffect1Fail() {
+        F2<TryEffect1<Integer, TryEffectException>, Integer, Validation<TryEffectException, Unit>> f =
+                TryEffect.f(TryEffect1<Integer, TryEffectException>::f);
+        Validation<TryEffectException, Unit> v = f.f(new AlwaysFail1(), 1);
+        assertThat(v.isFail(), is(true));
+        assertThat(v.fail(), is(new TryEffectException()));
+    }
+
+    class AlwaysSucceed0 implements TryEffect0<TryEffectException> {
+        @Override
+        public void f() throws TryEffectException {
+            // SUCCESS
+        }
+    }
+
+    class AlwaysSucceed1 implements TryEffect1<Integer, TryEffectException> {
+        @Override
+        public void f(Integer i) throws TryEffectException {
+            // SUCCESS;
+        }
+    }
+
+    class AlwaysFail0 implements TryEffect0<TryEffectException> {
+        @Override
+        public void f() throws TryEffectException {
+            throw new TryEffectException();
+        }
+    }
+
+    class AlwaysFail1 implements TryEffect1<Integer, TryEffectException> {
+        @Override
+        public void f(Integer i) throws TryEffectException {
+            throw new TryEffectException();
+        }
+    }
+
+    class TryEffectException extends Exception {
+        @Override
+        public boolean equals (Object obj) {
+            return (obj instanceof TryEffectException);
+        }
+    }
+}
diff --git a/core/src/test/java/fj/TryTest.java b/core/src/test/java/fj/TryTest.java
new file mode 100644
index 00000000..bd94e986
--- /dev/null
+++ b/core/src/test/java/fj/TryTest.java
@@ -0,0 +1,50 @@
+package fj;
+
+import fj.data.Validation;
+import fj.function.Try0;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class TryTest {
+
+    @Test
+    public void testTrySuccess() {
+        F<Try0<Integer, TryException>, Validation<TryException, Integer>> f =
+                Try.f(Try0::f);
+        Validation<TryException, Integer> v = f.f(new AlwaysSucceed());
+        assertThat(v.isSuccess(), is(true));
+        assertThat(v.success(), is(99));
+    }
+
+    @Test
+    public void testTryFail() {
+        F<Try0<Integer, TryException>, Validation<TryException, Integer>> f =
+                Try.f(Try0::f);
+        Validation<TryException, Integer> v = f.f(new AlwaysFail());
+        assertThat(v.isFail(), is(true));
+        assertThat(v.fail(), is(new TryException()));
+    }
+
+    class AlwaysSucceed implements Try0<Integer, TryException> {
+        @Override
+        public Integer f() throws TryException {
+            return 99;
+        }
+    }
+
+    class AlwaysFail implements Try0<Integer, TryException> {
+        @Override
+        public Integer f() throws TryException {
+            throw new TryException();
+        }
+    }
+
+    class TryException extends Exception {
+        @Override
+        public boolean equals (Object obj) {
+            return (obj instanceof TryException);
+        }
+    }
+}
diff --git a/core/src/test/java/fj/data/JavaTest.java b/core/src/test/java/fj/data/JavaTest.java
index 3b5a5785..2a9b6bfd 100644
--- a/core/src/test/java/fj/data/JavaTest.java
+++ b/core/src/test/java/fj/data/JavaTest.java
@@ -6,6 +6,8 @@
 import java.util.EnumSet;
 
 import static fj.Show.listShow;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
 
 /**
  * Created by MarkPerry on 14/07/2014.
@@ -16,7 +18,7 @@ public class JavaTest {
 	public void test1() {
 		// #33: Fixes ClassCastException
 		final List<Colors> colors = Java.<Colors>EnumSet_List().f(EnumSet.allOf(Colors.class));
-		listShow(Show.<Colors>anyShow()).print(colors);
+		assertThat(listShow(Show.<Colors>anyShow()).showS(colors), is("List(red,green,blue)"));
 	}
 
 	enum Colors {
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index 5d2778e5..3eeed489 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -23,7 +23,6 @@ public void traverseList() {
         int max = 3;
         List<Option<Integer>> actual = some(max).traverseList(a -> List.range(1, a + 1));
         List<Option<Integer>> expected = List.range(1, max + 1).map(i -> some(i));
-        System.out.println(String.format("actual: %s, expected: %s", actual.toString(), expected.toString()));
         assertTrue(actual.equals(expected));
     }
 
diff --git a/core/src/test/java/fj/data/SeqTest.java b/core/src/test/java/fj/data/SeqTest.java
index 27ec26e2..a7c85175 100644
--- a/core/src/test/java/fj/data/SeqTest.java
+++ b/core/src/test/java/fj/data/SeqTest.java
@@ -3,6 +3,8 @@
 import fj.P2;
 import org.junit.Test;
 
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -40,7 +42,8 @@ public void convertToString() {
     @Test
     public void test() {
         P2<Seq<Integer>, Seq<Integer>> p2 = Seq.single(1).split(5);
-        System.out.println(p2);
+        assertThat(p2._1(), is(Seq.single(1)));
+        assertThat(p2._2(), is(Seq.empty()));
     }
 
 }
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index 49840b78..b65e115c 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -107,9 +107,16 @@ public void testMinus() {
     }
 
     @Test
-    public void testSort() {
+    public void testSortSeq() {
         Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
         assertThat(s.sort(Ord.intOrd, Strategy.seqStrategy()),
                 is(s.sort(Ord.intOrd)));
     }
+
+    @Test
+    public void testSortThread() {
+        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, Strategy.simpleThreadStrategy()),
+                is(s.sort(Ord.intOrd)));
+    }
 }
diff --git a/core/src/test/java/fj/data/TreeMapTest.java b/core/src/test/java/fj/data/TreeMapTest.java
index d3e60936..96cb95b2 100644
--- a/core/src/test/java/fj/data/TreeMapTest.java
+++ b/core/src/test/java/fj/data/TreeMapTest.java
@@ -38,10 +38,6 @@ public void split() {
         Show<Set<String>> ss = Show.setShow(Show.stringShow);
         Show<Option<String>> so = Show.optionShow(Show.stringShow);
         Show<P3<Set<String>, Option<String>, Set<String>>> sp3 = Show.p3Show(ss, so, ss);
-        if (true) {
-            st.println(m2);
-            sp3.println(p);
-        }
 
         // assert equals
         Equal<Set<String>> seq = Equal.setEqual(Equal.stringEqual);
@@ -70,13 +66,6 @@ public void splitLookup() {
         List<Integer> rightList = List.range(pivot + 1, max + 1);
         TreeMap<Integer, String> rightMap = iterableTreeMap(Ord.intOrd, rightList.zip(rightList.map(i -> i.toString())));
 
-        // debug info
-        if (true) {
-            Show<TreeMap<Integer, String>> st = Show.treeMapShow(Show.intShow, Show.stringShow);
-            Show<P3<TreeMap<Integer, String>, Option<String>, TreeMap<Integer, String>>> sp3 = Show.p3Show(st, Show.optionShow(Show.stringShow), st);
-            sp3.println(p3);
-        }
-
         // do the assert
         Equal<TreeMap<Integer, String>> tme = Equal.treeMapEqual(Equal.intEqual, Equal.stringEqual);
         Equal<P3<TreeMap<Integer, String>, Option<String>, TreeMap<Integer, String>>> eq = Equal.p3Equal(tme, Equal.optionEqual(Equal.stringEqual), tme);

From ae70d20b6370531dca2efcd576eefbeb3e03228a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 29 Jul 2018 14:07:30 -0400
Subject: [PATCH 200/336] Implement Zipper Eq and Hash and add tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/Equal.java           |  30 +++---
 core/src/main/java/fj/Hash.java            |  20 ++++
 core/src/main/java/fj/data/Zipper.java     |  23 +++--
 core/src/test/java/fj/data/ZipperTest.java | 110 +++++++++++++++++++++
 4 files changed, 157 insertions(+), 26 deletions(-)
 create mode 100644 core/src/test/java/fj/data/ZipperTest.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index f427849a..9cf2a72a 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -1,19 +1,6 @@
 package fj;
 
-import fj.data.Array;
-import fj.data.Either;
-import fj.data.LazyString;
-import fj.data.List;
-import fj.data.Natural;
-import fj.data.NonEmptyList;
-import fj.data.Option;
-import fj.data.Seq;
-import fj.data.Set;
-import fj.data.Stream;
-import fj.data.Tree;
-import fj.data.TreeMap;
-import fj.data.Validation;
-import fj.data.Writer;
+import fj.data.*;
 import fj.data.hamt.BitSet;
 import fj.data.hlist.HList;
 import fj.data.vector.V2;
@@ -455,6 +442,21 @@ public static <A> Equal<Stream<A>> streamEqual(final Equal<A> ea) {
     });
   }
 
+  /**
+   * An equal instance for the {@link Zipper} type.
+   *
+   * @param ea Equality across the elements of the zipper.
+   * @return An equal instance for the {@link Zipper} type.
+   */
+  public static <A> Equal<Zipper<A>> zipperEqual(final Equal<A> ea) {
+    Equal<Stream<A>> se = Equal.streamEqual(ea);
+    return equalDef((a1, a2) ->
+        se.eq(a1.lefts(), a2.lefts()) &&
+        ea.eq(a1.focus(), a2.focus()) &&
+        se.eq(a1.rights(), a2.rights())
+    );
+  }
+
   /**
    * An equal instance for the {@link Array} type.
    *
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 14f8a9d7..708fe853 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -262,6 +262,26 @@ public static <A> Hash<Array<A>> arrayHash(final Hash<A> ha) {
     });
   }
 
+  /**
+   * A hash instance for the {@link Zipper} type.
+   *
+   * @param ha A hash for the elements of the zipper.
+   * @return A hash instance for the {@link Zipper} type.
+   */
+  public static <A> Hash<Zipper<A>> zipperHash(final Hash<A> ha) {
+    Hash<Stream<A>> sh = streamHash(ha);
+    return hash(as -> {
+        final int p = 419;
+        int r = 239;
+
+        r = p * r + sh.hash(as.lefts());
+        r = p * r + ha.hash(as.focus());
+        r = p * r + sh.hash(as.rights());
+
+        return r;
+    });
+  }
+
   /**
    * A hash instance for the {@link Tree} type.
    *
diff --git a/core/src/main/java/fj/data/Zipper.java b/core/src/main/java/fj/data/Zipper.java
index 24414ed2..2514d8e2 100644
--- a/core/src/main/java/fj/data/Zipper.java
+++ b/core/src/main/java/fj/data/Zipper.java
@@ -1,17 +1,6 @@
 package fj.data;
 
-import fj.Equal;
-import fj.F;
-import fj.F2;
-import fj.F2Functions;
-import fj.F3;
-import fj.Function;
-import fj.Ord;
-import fj.P;
-import fj.P1;
-import fj.P2;
-import fj.P3;
-import fj.Show;
+import fj.*;
 import fj.function.Integers;
 
 import java.util.Iterator;
@@ -106,6 +95,16 @@ public static <A> Ord<Zipper<A>> ord(final Ord<A> o) {
     return Ord.p3Ord(so, o, so).contramap(Zipper.p_());
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(Zipper.class, this, other, () -> Equal.zipperEqual(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.zipperHash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * An Equal instance for Zippers.
    *
diff --git a/core/src/test/java/fj/data/ZipperTest.java b/core/src/test/java/fj/data/ZipperTest.java
new file mode 100644
index 00000000..51c7b4ea
--- /dev/null
+++ b/core/src/test/java/fj/data/ZipperTest.java
@@ -0,0 +1,110 @@
+package fj.data;
+
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class ZipperTest {
+    @Test
+    public void testZipper() {
+        Zipper<Integer> z = Zipper.zipper(Stream.nil(), 0, Stream.range(1, 9));
+        assertThat(z.map(i -> i + 13).toStream(), is(Stream.range(13, 22)));
+    }
+
+    @Test
+    public void testNext() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.single(3));
+        z = z.next().some();
+        assertThat(z.lefts(), is(Stream.arrayStream(new Integer[]{2, 1})));
+        assertThat(z.focus(), is(3));
+        assertThat(z.rights(), is(Stream.nil()));
+    }
+
+    @Test
+    public void testNextNone() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.nil());
+        assertThat(z.next().isNone(), is(true));
+    }
+
+    @Test
+    public void testCycleNext() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.single(3));
+        assertThat(z.cycleNext(), is(z.next().some()));
+    }
+
+    @Test
+    public void testCycleNextLast() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.nil());
+        z = z.cycleNext();
+        assertThat(z.lefts(), is(Stream.nil()));
+        assertThat(z.focus(), is(1));
+        assertThat(z.rights(), is(Stream.single(2)));
+    }
+
+    @Test
+    public void testPrevious() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.single(3));
+        z = z.previous().some();
+        assertThat(z.lefts(), is(Stream.nil()));
+        assertThat(z.focus(), is(1));
+        assertThat(z.rights(), is(Stream.arrayStream(new Integer[]{2, 3})));
+    }
+
+    @Test
+    public void testPreviousNone() {
+        Zipper<Integer> z = Zipper.zipper(Stream.nil(), 2, Stream.single(3));
+        assertThat(z.previous().isNone(), is(true));
+    }
+
+    @Test
+    public void testCyclePrevious() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.single(3));
+        assertThat(z.cyclePrevious(), is(z.previous().some()));
+    }
+
+    @Test
+    public void testCyclePreviousFirst() {
+        Zipper<Integer> z = Zipper.zipper(Stream.nil(), 1, Stream.single(2));
+        z = z.cyclePrevious();
+        assertThat(z.lefts(), is(Stream.single(1)));
+        assertThat(z.focus(), is(2));
+        assertThat(z.rights(), is(Stream.nil()));
+    }
+
+    @Test
+    public void testInsertLeft() {
+        Zipper<Integer> z = Zipper.single(2);
+        z = z.insertLeft(1);
+        assertThat(z.lefts(), is(Stream.nil()));
+        assertThat(z.focus(), is(1));
+        assertThat(z.rights(), is(Stream.single(2)));
+    }
+
+    @Test
+    public void testInsertRight() {
+        Zipper<Integer> z = Zipper.single(2);
+        z = z.insertRight(3);
+        assertThat(z.lefts(), is(Stream.single(2)));
+        assertThat(z.focus(), is(3));
+        assertThat(z.rights(), is(Stream.nil()));
+    }
+
+    @Test
+    public void testDeleteOthers() {
+        Zipper<Integer> z = Zipper.zipper(Stream.single(1), 2, Stream.single(3));
+        z = z.deleteOthers();
+        assertThat(z.lefts(), is(Stream.nil()));
+        assertThat(z.focus(), is(2));
+        assertThat(z.rights(), is(Stream.nil()));
+    }
+
+    @Test
+    public void testFind() {
+        Zipper<Integer> z = Zipper.zipper(Stream.nil(), 0, Stream.range(1));
+        z = z.find(i -> i == 4).some();
+        assertThat(z.lefts(), is(Stream.arrayStream(new Integer[]{3, 2, 1, 0})));
+        assertThat(z.focus(), is(4));
+        assertThat(z.rights().take(3), is(Stream.range(5, 8)));
+    }
+}

From 954a12b31c7430fe4af0aecb0492f02960cc0796 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Thu, 2 Aug 2018 17:26:56 -0400
Subject: [PATCH 201/336] Add Vector tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/data/vector/VTest.java | 62 ++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 core/src/test/java/fj/data/vector/VTest.java

diff --git a/core/src/test/java/fj/data/vector/VTest.java b/core/src/test/java/fj/data/vector/VTest.java
new file mode 100644
index 00000000..027b8407
--- /dev/null
+++ b/core/src/test/java/fj/data/vector/VTest.java
@@ -0,0 +1,62 @@
+package fj.data.vector;
+
+import fj.P;
+import fj.P2;
+import fj.P3;
+import fj.P4;
+import fj.P5;
+import fj.P6;
+import fj.P7;
+import fj.P8;
+import fj.data.Array;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+public class VTest {
+    @Test
+    public void testVectorUp(){
+        final P2<Integer, Integer> p2 = P.p(2, 1);
+        final V2<Integer> v2 = V2.p(p2);
+        final V3<Integer> v3 = V3.cons(P.p(3), v2);
+        final V4<Integer> v4 = V4.cons(P.p(4), v3);
+        final V5<Integer> v5 = V5.cons(P.p(5), v4);
+        final V6<Integer> v6 = V6.cons(P.p(6), v5);
+        final V7<Integer> v7 = V7.cons(P.p(7), v6);
+        final V8<Integer> v8 = V8.cons(P.p(8), v7);
+        assertThat(v8.toArray(), is(Array.range(1, 9).reverse()));
+    }
+
+    @Test
+    public void testVectorP(){
+        final P2<Integer, Integer> p2 = P.p(1, 2);
+        final V2<Integer> v2 = V2.p(p2);
+        assertThat(v2.toArray(), is(Array.range(1, 3)));
+        assertThat(v2.p(), is(p2));
+        final P3<Integer, Integer, Integer> p3 = p2.append(3);
+        final V3<Integer> v3 = V3.p(p3);
+        assertThat(v3.toArray(), is(Array.range(1, 4)));
+        assertThat(v3.p(), is(p3));
+        final P4<Integer, Integer, Integer, Integer> p4 = p3.append(4);
+        final V4<Integer> v4 = V4.p(p4);
+        assertThat(v4.toArray(), is(Array.range(1, 5)));
+        assertThat(v4.p(), is(p4));
+        final P5<Integer, Integer, Integer, Integer, Integer> p5 = p4.append(5);
+        final V5<Integer> v5 = V5.p(p5);
+        assertThat(v5.toArray(), is(Array.range(1, 6)));
+        assertThat(v5.p(), is(p5));
+        final P6<Integer, Integer, Integer, Integer, Integer, Integer> p6 = p5.append(6);
+        final V6<Integer> v6 = V6.p(p6);
+        assertThat(v6.toArray(), is(Array.range(1, 7)));
+        assertThat(v6.p(), is(p6));
+        final P7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> p7 = p6.append(7);
+        final V7<Integer> v7 = V7.p(p7);
+        assertThat(v7.toArray(), is(Array.range(1, 8)));
+        assertThat(v7.p(), is(p7));
+        final P8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> p8 = p7.append(8);
+        final V8<Integer> v8 = V8.p(p8);
+        assertThat(v8.toArray(), is(Array.range(1, 9)));
+        assertThat(v8.p(), is(p8));
+    }
+}

From ba27e71970287988d0ca5125d7316439dd7dd1ef Mon Sep 17 00:00:00 2001
From: Gabor Liptak <gliptak@gmail.com>
Date: Thu, 2 Aug 2018 20:41:08 -0400
Subject: [PATCH 202/336] Add Optic tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/data/optic/IsoTest.java |  43 ++++++
 .../src/test/java/fj/data/optic/LensTest.java | 123 ++++++++++++++++++
 .../test/java/fj/data/optic/OptionalTest.java |  29 +++++
 .../test/java/fj/data/optic/PrismTest.java    |  29 +++++
 .../java/fj/data/optic/TraversalTest.java     |  23 ++++
 5 files changed, 247 insertions(+)
 create mode 100644 core/src/test/java/fj/data/optic/IsoTest.java
 create mode 100644 core/src/test/java/fj/data/optic/LensTest.java
 create mode 100644 core/src/test/java/fj/data/optic/OptionalTest.java
 create mode 100644 core/src/test/java/fj/data/optic/PrismTest.java
 create mode 100644 core/src/test/java/fj/data/optic/TraversalTest.java

diff --git a/core/src/test/java/fj/data/optic/IsoTest.java b/core/src/test/java/fj/data/optic/IsoTest.java
new file mode 100644
index 00000000..6cace533
--- /dev/null
+++ b/core/src/test/java/fj/data/optic/IsoTest.java
@@ -0,0 +1,43 @@
+package fj.data.optic;
+
+import fj.P;
+import fj.P2;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class IsoTest {
+    @Test
+    public void testIso() {
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Iso<Address, P2<Integer, String>> addressIso = Iso.iso(p -> P.p(p.number, p.street),
+                p -> new Address(p._1(), p._2()));
+        final Address a = addressIso.reverseGet(addressIso.get(oldAddress));
+        assertThat(a.number, is(oldAddress.number));
+        assertThat(a.street, is(oldAddress.street));
+    }
+
+    static final class Person {
+        String name;
+        Address address;
+
+        Person(String name, Address address) {
+            this.name = name;
+            this.address = address;
+        }
+    }
+
+    static final class Address {
+        int number;
+        String street;
+
+        public Address(int number, String street) {
+            this.number = number;
+            this.street = street;
+        }
+    }
+
+}
diff --git a/core/src/test/java/fj/data/optic/LensTest.java b/core/src/test/java/fj/data/optic/LensTest.java
new file mode 100644
index 00000000..d78fa0d0
--- /dev/null
+++ b/core/src/test/java/fj/data/optic/LensTest.java
@@ -0,0 +1,123 @@
+package fj.data.optic;
+
+import fj.F;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class LensTest {
+    @Test
+    public void testLensPersonGet() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, String> personNameLens = Lens.lens(p -> p.name, s -> p -> new Person(s, p.address));
+        final Lens<Person, Address> personAddressLens = Lens.lens(p -> p.address, a -> p -> new Person(p.name, a));
+        final Lens<Address, Integer> addressNumberLens = Lens.lens(a -> a.number, n -> a -> new Address(n, a.street));
+        final Lens<Address, String> addressStreetLens = Lens.lens(a -> a.street, s -> a -> new Address(a.number, s));
+        final Lens<Person, Integer> personNumberLens = personAddressLens.composeLens(addressNumberLens);
+        final Lens<Person, String> personStreetLens = personAddressLens.composeLens(addressStreetLens);
+        assertThat(personNameLens.get(oldPerson), is(oldName));
+        assertThat(personNumberLens.get(oldPerson), is(oldNumber));
+        assertThat(personStreetLens.get(oldPerson), is(oldStreet));
+    }
+
+    @Test
+    public void testLensPersonSetName() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, String> personNameLens = Lens.lens(p -> p.name, s -> p -> new Person(s, p.address));
+        String newName = "Bill";
+        Person p = personNameLens.set(newName).f(oldPerson);
+        assertThat(p.name, is(newName));
+        assertThat(p.address, is(oldPerson.address));
+    }
+
+    @Test
+    public void testLensPersonSetNumber() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, Address> personAddressLens = Lens.lens(p -> p.address, a -> p -> new Person(p.name, a));
+        final Lens<Address, Integer> addressNumberLens = Lens.lens(a -> a.number, n -> a -> new Address(n, a.street));
+        final Lens<Person, Integer> personNumberLens = personAddressLens.composeLens(addressNumberLens);
+        int newNumber = 20;
+        Person p = personNumberLens.set(newNumber).f(oldPerson);
+        assertThat(p.name, is(oldName));
+        assertThat(p.address.number, is(newNumber));
+        assertThat(p.address.street, is(oldStreet));
+    }
+
+    @Test
+    public void testLensPersonSetStreet() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, Address> personAddressLens = Lens.lens(p -> p.address, a -> p -> new Person(p.name, a));
+        final Lens<Address, Integer> addressNumberLens = Lens.lens(a -> a.number, n -> a -> new Address(n, a.street));
+        final Lens<Address, String> addressStreetLens = Lens.lens(a -> a.street, s -> a -> new Address(a.number, s));
+        final Lens<Person, String> personStreetLens = personAddressLens.composeLens(addressStreetLens);
+        String newStreet = "First St";
+        Person p = personStreetLens.set(newStreet).f(oldPerson);
+        assertThat(p.name, is(oldName));
+        assertThat(p.address.number, is(oldPerson.address.number));
+        assertThat(p.address.street, is(newStreet));
+    }
+
+    @Test
+    public void testLensPersonSetter() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, String> personNameLens = Lens.lens(p -> p.name, s -> p -> new Person(s, p.address));
+        String newName = "Bill";
+        F<Person, Person> setter = personNameLens.asSetter().set(newName);
+        Person p = setter.f(oldPerson);
+        assertThat(p.name, is(newName));
+        assertThat(p.address, is(oldPerson.address));
+    }
+
+    @Test
+    public void testLensPersonGetter() {
+        final String oldName = "Joe";
+        final int oldNumber = 10;
+        final String oldStreet = "Main St";
+        final Address oldAddress = new Address(oldNumber, oldStreet);
+        final Person oldPerson = new Person(oldName, oldAddress);
+        final Lens<Person, String> personNameLens = Lens.lens(p -> p.name, s -> p -> new Person(s, p.address));
+        assertThat(personNameLens.asGetter().get(oldPerson), is(oldName));
+    }
+
+    static final class Person {
+        String name;
+        Address address;
+
+        Person(String name, Address address) {
+            this.name = name;
+            this.address = address;
+        }
+    }
+
+    static final class Address {
+        int number;
+        String street;
+
+        public Address(int number, String street) {
+            this.number = number;
+            this.street = street;
+        }
+    }
+
+}
diff --git a/core/src/test/java/fj/data/optic/OptionalTest.java b/core/src/test/java/fj/data/optic/OptionalTest.java
new file mode 100644
index 00000000..07c3f79a
--- /dev/null
+++ b/core/src/test/java/fj/data/optic/OptionalTest.java
@@ -0,0 +1,29 @@
+package fj.data.optic;
+
+import fj.data.Option;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class OptionalTest {
+    @Test
+    public void testOptionalSome() {
+        Optional<String, Integer> o = Optional.optional(this::decode, i -> s -> s);
+        assertThat(o.getOption("18"), is(Option.some(18)));
+    }
+
+    @Test
+    public void testOptionalNone() {
+        Optional<String, Integer> o = Optional.optional(this::decode, i -> s -> s);
+        assertThat(o.getOption("Z"), is(Option.none()));
+    }
+
+    private Option<Integer> decode(String s) {
+        try {
+            return Option.some(Integer.decode(s));
+        } catch (NumberFormatException nfe) {
+            return Option.none();
+        }
+    }
+}
diff --git a/core/src/test/java/fj/data/optic/PrismTest.java b/core/src/test/java/fj/data/optic/PrismTest.java
new file mode 100644
index 00000000..da128d72
--- /dev/null
+++ b/core/src/test/java/fj/data/optic/PrismTest.java
@@ -0,0 +1,29 @@
+package fj.data.optic;
+
+import fj.data.Option;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class PrismTest {
+    @Test
+    public void testPrismSome() {
+        Prism<String, Integer> prism = Prism.prism(s -> decode(s), i -> i.toString());
+        assertThat(prism.getOption("18"), is(Option.some(18)));
+    }
+
+    @Test
+    public void testPrismNone() {
+        Prism<String, Integer> prism = Prism.prism(s -> decode(s), i -> i.toString());
+        assertThat(prism.getOption("Z"), is(Option.none()));
+    }
+
+    private Option<Integer> decode(String s) {
+        try {
+            return Option.some(Integer.decode(s));
+        } catch (NumberFormatException nfe) {
+            return Option.none();
+        }
+    }
+}
diff --git a/core/src/test/java/fj/data/optic/TraversalTest.java b/core/src/test/java/fj/data/optic/TraversalTest.java
new file mode 100644
index 00000000..cadd6ccf
--- /dev/null
+++ b/core/src/test/java/fj/data/optic/TraversalTest.java
@@ -0,0 +1,23 @@
+package fj.data.optic;
+
+import fj.Monoid;
+import fj.data.Either;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class TraversalTest {
+    @Test
+    public void testTraversalLeft() {
+        final Traversal<Either<Integer, Integer>, Integer> t = Traversal.codiagonal();
+        assertThat(t.fold(Monoid.intMinMonoid).f(Either.left(3)), is(3));
+    }
+
+    @Test
+    public void testTraversalRight() {
+        final Traversal<Either<Integer, Integer>, Integer> t = Traversal.codiagonal();
+        assertThat(t.fold(Monoid.intMinMonoid).f(Either.right(2)), is(2));
+    }
+
+}

From 22cf4b4a06298c79701e61384fa5baffb0eb34a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Fri, 3 Aug 2018 21:03:45 -0400
Subject: [PATCH 203/336] Add Parser tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/Equal.java             |  8 +++
 core/src/main/java/fj/Hash.java              | 20 ++++++++
 core/src/main/java/fj/Show.java              | 14 ++++++
 core/src/main/java/fj/parser/Result.java     | 19 +++++++
 core/src/test/java/fj/parser/ParserTest.java | 52 ++++++++++++++++++++
 5 files changed, 113 insertions(+)
 create mode 100644 core/src/test/java/fj/parser/ParserTest.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 9cf2a72a..a798a736 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -10,6 +10,7 @@
 import fj.data.vector.V6;
 import fj.data.vector.V7;
 import fj.data.vector.V8;
+import fj.parser.Result;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -355,6 +356,13 @@ public static <A, B> Equal<Either<A, B>> eitherEqual(final Equal<A> ea, final Eq
     ));
   }
 
+  public static <I, A> Equal<Result<I, A>> resultEqual(final Equal<A> ea, final Equal<I> ei) {
+    Definition<A> eaDef = ea.def;
+    Definition<I> eiDef= ei.def;
+    return equalDef((r1, r2) -> eaDef.equal(r1.value(), r2.value()) && eiDef.equal(r1.rest(), r2.rest()));
+  }
+
+
   /**
    * An equal instance for the {@link Validation} type.
    *
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 708fe853..da443ab2 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -10,6 +10,7 @@
 import fj.data.vector.V6;
 import fj.data.vector.V7;
 import fj.data.vector.V8;
+import fj.parser.Result;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -162,6 +163,25 @@ public static <A, B> Hash<Either<A, B>> eitherHash(final Hash<A> ha, final Hash<
     return hash(e -> e.isLeft() ? ha.hash(e.left().value()) : hb.hash(e.right().value()));
   }
 
+  /**
+   * A hash instance for the {@link Result} type.
+   *
+   * @param ha Hash the <code>Result</code> value.
+   * @param hi Hash the <code>Result</code> remainder.
+   * @return A hash instance for the {@link Result} type.
+   */
+  public static <I, A> Hash<Result<I, A>> resultHash(Hash<A> ha, Hash<I> hi) {
+    return hash(res -> {
+      final int p = 419;
+      int r = 239;
+
+      r = p * r + ha.hash(res.value());
+      r = p * r + hi.hash(res.rest());
+
+      return r;
+    });
+  }
+
   /**
    * A hash instance for the {@link Validation} type.
    *
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 2d2c4707..cd57897b 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -12,6 +12,7 @@
 import fj.data.vector.V6;
 import fj.data.vector.V7;
 import fj.data.vector.V8;
+import fj.parser.Result;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -255,6 +256,19 @@ public static <A, B> Show<Either<A, B>> eitherShow(final Show<A> sa, final Show<
            fromString("Right(").append(sb.f.f(e.right().value())).append(single(')')));
   }
 
+  /**
+   * A show instance for the {@link Result} type.
+   *
+   * @param sa Show for the {@link Result} value.
+   * @param si Show for the {@link Result} remainder.
+   * @return A show instance for the {@link Result} type.
+   */
+  public static <I, A> Show<Result<I, A>> resultShow(Show<A> sa, Show<I> si) {
+    return show(res ->
+            fromString("Result(").append(sa.f.f(res.value()))
+                    .append(single(',')).append(si.f.f(res.rest())).append(single(')')));
+  }
+
   /**
    * A show instance for the {@link Validation} type.
    *
diff --git a/core/src/main/java/fj/parser/Result.java b/core/src/main/java/fj/parser/Result.java
index 51e115f6..b8acc6c4 100644
--- a/core/src/main/java/fj/parser/Result.java
+++ b/core/src/main/java/fj/parser/Result.java
@@ -1,6 +1,9 @@
 package fj.parser;
 
+import fj.Equal;
 import fj.F;
+import fj.Hash;
+import fj.Show;
 
 import static fj.Function.curry;
 
@@ -21,6 +24,22 @@ private Result(final I i, final A a) {
     this.a = a;
   }
 
+  @Override
+  public final int hashCode() {
+    return Hash.resultHash(Hash.<A>anyHash(), Hash.<I>anyHash()).hash(this);
+  }
+
+  @Override
+  public final String toString() {
+    return Show.resultShow(Show.<A>anyShow(), Show.<I>anyShow()).showS(this);
+  }
+
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(Result.class, this, other, () -> Equal.resultEqual(Equal.anyEqual(), Equal.anyEqual()));
+  }
+
+
   /**
    * The remainder of the parse input.
    *
diff --git a/core/src/test/java/fj/parser/ParserTest.java b/core/src/test/java/fj/parser/ParserTest.java
new file mode 100644
index 00000000..a3f623f5
--- /dev/null
+++ b/core/src/test/java/fj/parser/ParserTest.java
@@ -0,0 +1,52 @@
+package fj.parser;
+
+import fj.F;
+import fj.F0;
+import fj.data.Stream;
+import fj.data.Validation;
+import org.junit.Test;
+
+import static fj.parser.Result.result;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class ParserTest {
+    @Test
+    public void testParserFail() {
+        final Parser<String, String, Exception> fail = Parser.fail(new ParseException());
+        assertThat(fail.parse("").fail(), is(new ParseException()));
+    }
+
+    @Test
+    public void testParserValue() {
+        final Parser<String, String, Exception> p = Parser.parser(s -> s.isEmpty() ?
+                Validation.fail(new ParseException()) :
+                Validation.success(result(s.substring(1), s.substring(0, 1)))
+        );
+        final Result<String, String> r = p.parse("abc").success();
+        assertThat(r.value(), is("a"));
+        assertThat(r.rest(), is("bc"));
+    }
+
+    @Test
+    public void testParserBind() {
+        final Parser<String, String, Exception> p = Parser.value("a");
+        final Parser<String, String, Exception> fail = Parser.fail(new ParseException());
+        assertThat(p.bind(o -> fail).parse("aaaa").fail(), is(new ParseException()));
+    }
+
+    @Test
+    public void testParserStream() {
+        Stream<Character> s = Stream.fromString("abc");
+        Result<Stream<Character>, Character> r = Parser.CharsParser.character('a').parse(s).success();
+        assertThat(r, is(Result.result(Stream.fromString("bc"), 'a')));
+    }
+
+    class ParseException extends Exception {
+        @Override
+        public boolean equals (Object obj) {
+            return (obj instanceof ParseException);
+        }
+    }
+
+}

From ca67637f62aba38fc84056378601b9e88bb69a0c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 4 Aug 2018 15:24:14 -0400
Subject: [PATCH 204/336] Implement Vector equals
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/data/vector/V2.java    | 10 ++++
 core/src/main/java/fj/data/vector/V3.java    | 10 ++++
 core/src/main/java/fj/data/vector/V4.java    | 10 ++++
 core/src/main/java/fj/data/vector/V5.java    | 10 ++++
 core/src/main/java/fj/data/vector/V6.java    | 10 ++++
 core/src/main/java/fj/data/vector/V7.java    | 10 ++++
 core/src/main/java/fj/data/vector/V8.java    | 10 ++++
 core/src/test/java/fj/data/vector/VTest.java | 60 +++++++++++++++++---
 8 files changed, 122 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/data/vector/V2.java b/core/src/main/java/fj/data/vector/V2.java
index fdab115c..d1ec5e74 100644
--- a/core/src/main/java/fj/data/vector/V2.java
+++ b/core/src/main/java/fj/data/vector/V2.java
@@ -23,6 +23,16 @@ private V2(final P2<A, A> inner) {
     this.inner = inner;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V2.class, this, other, () -> Equal.v2Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v2Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-2 from a homogeneous product-2.
    *
diff --git a/core/src/main/java/fj/data/vector/V3.java b/core/src/main/java/fj/data/vector/V3.java
index 9b25258f..523c08ae 100644
--- a/core/src/main/java/fj/data/vector/V3.java
+++ b/core/src/main/java/fj/data/vector/V3.java
@@ -23,6 +23,16 @@ private V3(final P1<A> head, final V2<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V3.class, this, other, () -> Equal.v3Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v3Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-3 from a homogeneous product-3.
    *
diff --git a/core/src/main/java/fj/data/vector/V4.java b/core/src/main/java/fj/data/vector/V4.java
index 1f39346b..808e7bab 100644
--- a/core/src/main/java/fj/data/vector/V4.java
+++ b/core/src/main/java/fj/data/vector/V4.java
@@ -23,6 +23,16 @@ private V4(final P1<A> head, final V3<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V4.class, this, other, () -> Equal.v4Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v4Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-4 from a homogeneous product-4.
    *
diff --git a/core/src/main/java/fj/data/vector/V5.java b/core/src/main/java/fj/data/vector/V5.java
index 0119dcf9..8f0583a3 100644
--- a/core/src/main/java/fj/data/vector/V5.java
+++ b/core/src/main/java/fj/data/vector/V5.java
@@ -23,6 +23,16 @@ private V5(final P1<A> head, final V4<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V5.class, this, other, () -> Equal.v5Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v5Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-5 from a homogeneous product-5.
    *
diff --git a/core/src/main/java/fj/data/vector/V6.java b/core/src/main/java/fj/data/vector/V6.java
index 47a0c4e7..880deaff 100644
--- a/core/src/main/java/fj/data/vector/V6.java
+++ b/core/src/main/java/fj/data/vector/V6.java
@@ -23,6 +23,16 @@ private V6(final P1<A> head, final V5<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V6.class, this, other, () -> Equal.v6Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v6Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-6 from a homogeneous product-6.
    *
diff --git a/core/src/main/java/fj/data/vector/V7.java b/core/src/main/java/fj/data/vector/V7.java
index c0dfa4b6..2127d5f4 100644
--- a/core/src/main/java/fj/data/vector/V7.java
+++ b/core/src/main/java/fj/data/vector/V7.java
@@ -23,6 +23,16 @@ private V7(final P1<A> head, final V6<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V7.class, this, other, () -> Equal.v7Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v7Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-7 from a homogeneous product-7.
    *
diff --git a/core/src/main/java/fj/data/vector/V8.java b/core/src/main/java/fj/data/vector/V8.java
index f01dc2fe..9ca7b618 100644
--- a/core/src/main/java/fj/data/vector/V8.java
+++ b/core/src/main/java/fj/data/vector/V8.java
@@ -23,6 +23,16 @@ private V8(final P1<A> head, final V7<A> tail) {
     this.tail = tail;
   }
 
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(V8.class, this, other, () -> Equal.v8Equal(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.v8Hash(Hash.<A>anyHash()).hash(this);
+  }
+
   /**
    * Creates a vector-8 from a homogeneous product-8.
    *
diff --git a/core/src/test/java/fj/data/vector/VTest.java b/core/src/test/java/fj/data/vector/VTest.java
index 027b8407..9a3709ac 100644
--- a/core/src/test/java/fj/data/vector/VTest.java
+++ b/core/src/test/java/fj/data/vector/VTest.java
@@ -1,13 +1,6 @@
 package fj.data.vector;
 
-import fj.P;
-import fj.P2;
-import fj.P3;
-import fj.P4;
-import fj.P5;
-import fj.P6;
-import fj.P7;
-import fj.P8;
+import fj.*;
 import fj.data.Array;
 import org.junit.Test;
 
@@ -59,4 +52,55 @@ public void testVectorP(){
         assertThat(v8.toArray(), is(Array.range(1, 9)));
         assertThat(v8.p(), is(p8));
     }
+
+    @Test
+    public void testVectorFunc2() {
+        V2<Integer> v2 = V.v(() -> 2, () -> 1);
+        F2<Integer, Integer, V2<Integer>> fv2 = V.v2();
+        V2<Integer> vf2 = fv2.f(2, 1);
+        assertThat(vf2, is(v2));
+    }
+
+    @Test
+    public void testVectorFunc3() {
+        V3<Integer> v3 = V.v(P.p(3), () -> 2, () -> 1);
+        F3<Integer, Integer, Integer, V3<Integer>> fv3 = V.v3();
+        V3<Integer> vf3 = fv3.f(3, 2, 1);
+        assertThat(vf3, is(v3));
+    }
+
+    @Test
+    public void testVectorFunc4() {
+        V4<Integer> v4 = V.v(P.p(4), P.p(3), () -> 2, () -> 1);
+        F4<Integer, Integer, Integer, Integer, V4<Integer>> fv4 = V.v4();
+        V4<Integer> vf4 = fv4.f(4, 3, 2, 1);
+        assertThat(vf4, is(v4));
+    }
+
+    @Test
+    public void testVectorFunc5() {
+        V5<Integer> v5 = V.v(P.p(5), P.p(4), P.p(3), () -> 2, () -> 1);
+        F5<Integer, Integer, Integer, Integer, Integer, V5<Integer>> fv5 = V.v5();
+        V5<Integer> vf5 = fv5.f(5, 4, 3, 2, 1);
+        assertThat(vf5, is(v5));
+    }
+
+    @Test
+    public void testVectorMap() {
+        final V2<Integer> v2 = V.v(() -> 2, () -> 1);
+        assertThat(v2, is(v2.map(i -> i * 1)));
+        final V3<Integer> v3 = V3.cons(P.p(3), v2);
+        assertThat(v3, is(v3.map(i -> i * 1)));
+        final V4<Integer> v4 = V4.cons(P.p(4), v3);
+        assertThat(v4, is(v4.map(i -> i * 1)));
+        final V5<Integer> v5 = V5.cons(P.p(5), v4);
+        assertThat(v5, is(v5.map(i -> i * 1)));
+        final V6<Integer> v6 = V6.cons(P.p(6), v5);
+        assertThat(v6, is(v6.map(i -> i * 1)));
+        final V7<Integer> v7 = V7.cons(P.p(7), v6);
+        assertThat(v7, is(v7.map(i -> i * 1)));
+        final V8<Integer> v8 = V8.cons(P.p(8), v7);
+        assertThat(v8, is(v8.map(i -> i * 1)));
+    }
+
 }

From 7e149a63b478ce943b4e8c5d2cd5c7c909a71eae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 11 Aug 2018 19:42:46 -0400
Subject: [PATCH 205/336] Add FingerTree tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/FWFunctionsTest.java    |  1 -
 .../fj/data/fingertrees/FingerTreeTest.java   | 37 ++++++++++++++-----
 2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/core/src/test/java/fj/FWFunctionsTest.java b/core/src/test/java/fj/FWFunctionsTest.java
index b9ce65d5..c1f69718 100644
--- a/core/src/test/java/fj/FWFunctionsTest.java
+++ b/core/src/test/java/fj/FWFunctionsTest.java
@@ -2,7 +2,6 @@
 
 import org.junit.Test;
 
-import fj.F1W;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 2a64b44b..57e1fae6 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -1,19 +1,19 @@
 package fj.data.fingertrees;
 
+import fj.Function;
 import fj.P;
 import fj.P2;
-import fj.Show;
 import fj.data.List;
-import fj.data.Stream;
+import fj.data.Option;
 import org.junit.Test;
 
-import static fj.P.p;
-import static fj.Show.intShow;
-import static fj.test.Property.prop;
-import static fj.test.Property.property;
-import static java.lang.System.out;
+import static fj.Monoid.intAdditionMonoid;
+import static fj.Monoid.intMinMonoid;
+import static fj.data.fingertrees.FingerTree.measured;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
+import static org.hamcrest.core.Is.is;
+
 
 /**
  * Created by MarkPerry on 10/10/2015.
@@ -24,18 +24,35 @@ public class FingerTreeTest {
 
     @Test
     public void size() {
-        validateSize(List.list(-92, 68, 54, -77, -18, 67));
-        validateSize(List.list(-92, 68, 54, -77, -18, 67, -60, 23, -70, 99, 66, -79, -5));
+        validateOperations(List.list(-92, 68, 54, -77, -18, 67));
+        validateOperations(List.list(-92, 68, 54, -77, -18, 67, -60, 23, -70, 99, 66, -79, -5));
     }
 
-    void validateSize(List<Integer> list) {
+    void validateOperations(List<Integer> list) {
         FingerTree<Integer, Integer> ft = list.foldLeft(
             (acc, i) -> acc.snoc(i), FingerTree.<Integer>emptyIntAddition()
         );
         assertThat(ft.measure(), equalTo(list.length()));
+        assertThat(ft.foldLeft((s, i) -> s + 1, 0), equalTo(list.length()));
+        assertThat(ft.foldRight((i, s) -> 1 + s, 0), equalTo(list.length()));
+        assertThat(ft.filter(e -> e.equals(-77)).head(), equalTo(-77));
         assertThat(ft.length(), equalTo(list.length()));
     }
 
+    @Test
+    public void testHeadOption() {
+        assertThat(Empty.emptyIntAddition().headOption(), is(Option.none()));
+        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        assertThat(ft.headOption(), is(Option.some(1)));
+    }
+
+    @Test
+    public void testUncons() {
+        assertThat(Empty.emptyIntAddition().uncons(0, (h, t) -> h), is(0));
+        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        assertThat(ft.uncons(0, (h, t) -> h), is(1));
+    }
+
     public FingerTree<Integer, Integer> midSeq() {
         FingerTree<Integer, Integer> ft = FingerTree.emptyIntAddition();
         return List.range(1, SIZE).foldLeft(ft2 -> i -> ft2.snoc(i), ft);

From c2392a12e6e4a4f61508a2fd0f9e905bd5d65c0e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 13 Aug 2018 16:40:27 -0400
Subject: [PATCH 206/336] Add Reader/Writer tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 props-core/src/test/java/fj/data/ReaderTest.java | 16 +++++++++++++++-
 props-core/src/test/java/fj/data/WriterTest.java | 14 ++++++++++----
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 8494336e..87e2b52a 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -11,6 +11,8 @@
 import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -24,7 +26,6 @@ public void testMap() {
         // example taken from http://learnyouahaskell.com/for-a-few-monads-more
         int x = Reader.unit((Integer i) -> i + 3).map(i -> i * 5).f(8);
         assertTrue(x == 55);
-//        System.out.println(x); // 55
     }
 
     @Test
@@ -108,6 +109,19 @@ public void testAssociativity() {
         PropertyAssert.assertResult(p);
     }
 
+    @Test
+    public void testAndThen() {
+        final int y = Reader.unit((Integer i) -> i * 2).andThen(i -> i + 10).f(10);
+        assertThat(y, is(30));
+    }
+
+    @Test
+    public void testBind() {
+        final int y = Reader.unit((Integer i) -> i * 2)
+                .bind(a -> Reader.unit(i -> a + i + 11)).f(10);
+        assertThat(y, is(41));
+    }
+
     public Gen<Reader<Integer, Integer>> arbReader() {
         return Arbitrary.arbReader(cogenInteger, arbInteger);
     }
diff --git a/props-core/src/test/java/fj/data/WriterTest.java b/props-core/src/test/java/fj/data/WriterTest.java
index 5f0ac122..25f99b22 100644
--- a/props-core/src/test/java/fj/data/WriterTest.java
+++ b/props-core/src/test/java/fj/data/WriterTest.java
@@ -2,8 +2,7 @@
 
 import fj.Equal;
 import fj.F;
-import fj.data.test.PropertyAssert;
-import fj.test.Arbitrary;
+import fj.P;
 import fj.test.Gen;
 import fj.test.Property;
 import org.junit.Assert;
@@ -14,7 +13,8 @@
 import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
 
 /**
  * Created by MarkPerry on 17/12/2014.
@@ -107,7 +107,13 @@ public void testAssociativity() {
         assertResult(p);
     }
 
-
+    @Test
+    public void testUnit() {
+        Writer<String, String> w = Writer.unit("+").tell("foo").tell("bar");
+        assertThat(w.run(), is(P.p("foobar", "+")));
+        assertThat(w.log(), is("foobar"));
+        assertThat(w.value(), is("+"));
+    }
 
 
 }

From 69fbd1d451d3382aee4e5bca5bd775b6631fc0d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 12 Aug 2018 13:04:21 -0400
Subject: [PATCH 207/336] Add TreeZipper tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/Equal.java              | 20 ++++++++++++
 core/src/main/java/fj/Hash.java               | 26 ++++++++++++++-
 core/src/main/java/fj/data/TreeZipper.java    | 25 +++++++++++++--
 core/src/test/java/fj/FFunctionsTest.java     | 18 +++++++++++
 .../src/test/java/fj/data/TreeZipperTest.java | 32 +++++++++++++++++++
 5 files changed, 117 insertions(+), 4 deletions(-)
 create mode 100644 core/src/test/java/fj/data/TreeZipperTest.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index a798a736..5cd31aeb 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -3,6 +3,7 @@
 import fj.data.*;
 import fj.data.hamt.BitSet;
 import fj.data.hlist.HList;
+import fj.data.optic.Traversal;
 import fj.data.vector.V2;
 import fj.data.vector.V3;
 import fj.data.vector.V4;
@@ -466,6 +467,25 @@ public static <A> Equal<Zipper<A>> zipperEqual(final Equal<A> ea) {
   }
 
   /**
+   * An equal instance for the {@link TreeZipper} type.
+   *
+   * @param ea Equality across the elements of the tree zipper.
+   * @return An equal instance for the {@link TreeZipper} type.
+   */
+  public static <A> Equal<TreeZipper<A>> treeZipperEqual(final Equal<A> ea) {
+      final Equal<Tree<A>> te = Equal.treeEqual(ea);
+      final Equal<Stream<Tree<A>>> st = streamEqual(Equal.treeEqual(ea));
+      final Equal<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>> sp =
+              streamEqual(p3Equal(streamEqual(treeEqual(ea)), ea, streamEqual(treeEqual(ea))));
+      return equalDef((a1, a2) ->
+              te.eq(a1.focus(), a2.focus()) &&
+                      st.eq(a1.lefts(), a2.lefts()) &&
+                      st.eq(a1.rights(), a2.rights()) &&
+                      sp.eq(a1.parents(), a2.parents())
+      );
+  }
+
+    /**
    * An equal instance for the {@link Array} type.
    *
    * @param ea Equality across the elements of the array.
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index da443ab2..8d0a4e4c 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -302,7 +302,31 @@ public static <A> Hash<Zipper<A>> zipperHash(final Hash<A> ha) {
     });
   }
 
-  /**
+    /**
+     * A hash instance for the {@link TreeZipper} type.
+     *
+     * @param ha A hash for the elements of the tree zipper.
+     * @return A hash instance for the {@link TreeZipper} type.
+     */
+    public static <A> Hash<TreeZipper<A>> treeZipperHash(final Hash<A> ha) {
+        Hash<Tree<A>> th = treeHash(ha);
+        Hash<Stream<Tree<A>>> sth = streamHash(treeHash(ha));
+        Hash<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>> tsp =
+                streamHash(p3Hash(streamHash(treeHash(ha)), ha, streamHash(treeHash(ha))));
+        return hash(as -> {
+            final int p = 419;
+            int r = 239;
+
+            r = p * r + th.hash(as.focus());
+            r = p * r + sth.hash(as.lefts());
+            r = p * r + sth.hash(as.rights());
+            r = p * r + tsp.hash(as.parents());
+
+            return r;
+        });
+    }
+
+    /**
    * A hash instance for the {@link Tree} type.
    *
    * @param ha A hash for the elements of the tree.
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index c94287cf..46392d20 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -54,7 +54,17 @@ private TreeZipper(final Tree<A> tree,
     this.parents = parents;
   }
 
-  /**
+    @Override
+    public final boolean equals(Object other) {
+        return Equal.equals0(TreeZipper.class, this, other, () -> Equal.treeZipperEqual(Equal.anyEqual()));
+    }
+
+    @Override
+    public final int hashCode() {
+        return Hash.treeZipperHash(Hash.<A>anyHash()).hash(this);
+    }
+
+    /**
    * Creates a new tree zipper given a currently selected tree, a forest on the left, a forest on the right,
    * and a stream of parent contexts.
    *
@@ -341,8 +351,17 @@ public Stream<Tree<A>> lefts() {
    * @return the right siblings of the currently focused node.
    */
   public Stream<Tree<A>> rights() {
-    return rights;
-  }
+        return rights;
+    }
+
+  /**
+   * Returns the parents of the currently focused node.
+   *
+   * @return the parents of the currently focused node.
+   */
+  public Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents() {
+        return parents;
+    }
 
   /**
    * Indicates whether the current node is at the top of the tree.
diff --git a/core/src/test/java/fj/FFunctionsTest.java b/core/src/test/java/fj/FFunctionsTest.java
index 9d38e1f5..e13b1f2b 100644
--- a/core/src/test/java/fj/FFunctionsTest.java
+++ b/core/src/test/java/fj/FFunctionsTest.java
@@ -1,5 +1,7 @@
 package fj;
 
+import fj.data.Tree;
+import fj.data.TreeZipper;
 import org.junit.Test;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
@@ -22,4 +24,20 @@ public void testApply() {
         F<Integer, Integer> f1 = F2Functions.f(f2, 2);
         assertThat(F1Functions.f(f1, 1).f(), is(36));
     }
+
+    @Test
+    public void testTreeK() {
+        final Tree<Integer> t1 = F1Functions.<Integer, Integer>treeK(Function.identity()).f(1);
+        final Tree<Integer> t2 = F1Functions.<Integer, Integer>treeK(Function.identity()).f(2);
+        assertThat(F1Functions.<Integer, Integer>mapTree(i -> i + 1).f(t1),
+                is(F1Functions.<Integer, Integer>mapTree(i -> i * 1).f(t2)));
+    }
+
+    @Test
+    public void testTreeZipperK() {
+        final TreeZipper<Integer> tz1 = F1Functions.<Integer, Integer>treeZipperK(Function.identity()).f(1);
+        final TreeZipper<Integer> tz2 = F1Functions.<Integer, Integer>treeZipperK(Function.identity()).f(2);
+        assertThat(F1Functions.<Integer, Integer>mapTreeZipper(i -> i + 1).f(tz1),
+                is(F1Functions.<Integer, Integer>mapTreeZipper(i -> i * 1).f(tz2)));
+    }
 }
diff --git a/core/src/test/java/fj/data/TreeZipperTest.java b/core/src/test/java/fj/data/TreeZipperTest.java
new file mode 100644
index 00000000..c52f4111
--- /dev/null
+++ b/core/src/test/java/fj/data/TreeZipperTest.java
@@ -0,0 +1,32 @@
+package fj.data;
+
+import org.junit.Test;
+
+import static fj.data.Option.none;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class TreeZipperTest {
+    @Test
+    public void testDelete() {
+        final Tree<Integer> t = Tree.node(1, List.single(Tree.leaf(2)));
+        final TreeZipper<Integer> tz = TreeZipper.fromTree(t);
+        assertThat(tz.delete(), is(none()));
+    }
+
+    @Test
+    public void testDeleteForest() {
+        final Tree<Integer> t = Tree.node(1, List.single(Tree.leaf(2)));
+        final TreeZipper<Integer> tz = TreeZipper.fromForest(Stream.single(t)).some();
+        assertThat(tz.delete(), is(none()));
+
+    }
+
+    @Test
+    public void testHash() {
+        final Tree<Integer> t = Tree.node(1, List.single(Tree.leaf(2)));
+        final TreeZipper<Integer> tz1 = TreeZipper.fromForest(Stream.single(t)).some();
+        final TreeZipper<Integer> tz2 = TreeZipper.fromForest(Stream.single(t)).some();
+        assertThat(tz1.hashCode(), is(tz2.hashCode()));
+    }
+}

From 02d05ebaa451c33a1c0eedbcc1408e35eec7ad60 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 18 Aug 2018 22:41:08 +0200
Subject: [PATCH 208/336] ChangeLog of 4.8 release.

---
 .changelogged.yaml | 14 ++++++++++++++
 ChangeLog.md       | 33 +++++++++++++++++++++++++++++++++
 build.gradle       |  4 ++--
 3 files changed, 49 insertions(+), 2 deletions(-)
 create mode 100644 .changelogged.yaml
 create mode 100644 ChangeLog.md

diff --git a/.changelogged.yaml b/.changelogged.yaml
new file mode 100644
index 00000000..46180488
--- /dev/null
+++ b/.changelogged.yaml
@@ -0,0 +1,14 @@
+changelogs:
+  - changelog: ChangeLog.md
+
+    ignore_files:
+      - "*ChangeLog*.md"
+      - .changelogged.yaml
+
+    ignore_commits: []
+
+branch: upstream/master
+
+entry_format: "  - %message% (see [%link%](%id%));"
+
+editor_command: "nano -EiT 2"
diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
index 00000000..24276f35
--- /dev/null
+++ b/ChangeLog.md
@@ -0,0 +1,33 @@
+4.8
+---
+
+### Enhancements
+
+- Enable upload of snapshot artifacts. (see [`e834e8b`](https://github.com/functionaljava/functionaljava/commit/e834e8b));
+- Add append methods to all Px classes. Fix #326 (see [`065ed43`](https://github.com/functionaljava/functionaljava/commit/065ed43));
+- Introduce the Eval monad (see [`98294fc`](https://github.com/functionaljava/functionaljava/commit/98294fc));
+- Fluent Equal/Ord construction (see [#333](https://github.com/functionaljava/functionaljava/pull/333));
+- Implement Zipper Eq and Hash and add tests (see [#343](https://github.com/functionaljava/functionaljava/pull/343));
+- Implement Vector equals (see [#350](https://github.com/functionaljava/functionaljava/pull/350));
+
+### Fixes
+
+- Fixed a bug in the NonEmptyList Semigroup implementation that resulted in the same NonEmptyList appended to itself. (Regression in 4.7, see [`07f94fa`](https://github.com/functionaljava/functionaljava/commit/07f94fa));
+- Fixes #334: exception in Either.LeftProjection.traverseIO (see [#335](https://github.com/functionaljava/functionaljava/pull/335));
+
+### Internal
+
+- Added Scalacheck Arbitrary implementations for Natural and NonEmptyList. (see [`405c3ec`](https://github.com/functionaljava/functionaljava/commit/405c3ec));
+- Added unit test coverage for Semigroup implementations.  The StringBuffer and StringBuilder tests fail because both of those types are mutable.  The IO test fails because the ArbitraryIO implementation does not implement equals. (see [`ef81130`](https://github.com/functionaljava/functionaljava/commit/ef81130));
+- Fixed the ArbitraryIO implementation and created a Properties object for testing the IO semigroup. (see [`a8e979f`](https://github.com/functionaljava/functionaljava/commit/a8e979f));
+- Added working tests coverage for the StringBuffer and StringBuilder semigroup implementations.  Added the Semigroup tests to the list of Scalacheck test suite. (see [`aa4de33`](https://github.com/functionaljava/functionaljava/commit/aa4de33));
+- Equal: remove reference to static field of LazyString. Fix #321 (see [`6c6dabd`](https://github.com/functionaljava/functionaljava/commit/6c6dabd));
+- Add IOFunctions tests (see [#340](https://github.com/functionaljava/functionaljava/pull/340));
+- Add Stream tests (see [#341](https://github.com/functionaljava/functionaljava/pull/341));
+- Add tests for Try, F, FW, Digit (see [#346](https://github.com/functionaljava/functionaljava/pull/346));
+- Add Vector tests (see [#347](https://github.com/functionaljava/functionaljava/pull/347));
+- Add Optic tests (see [#348](https://github.com/functionaljava/functionaljava/pull/348));
+- Add Parser tests (see [#349](https://github.com/functionaljava/functionaljava/pull/349));
+- Add FingerTree tests (see [#351](https://github.com/functionaljava/functionaljava/pull/351));
+- Add TreeZipper tests (see [#352](https://github.com/functionaljava/functionaljava/pull/352));
+- Add Reader/Writer tests (see [#353](https://github.com/functionaljava/functionaljava/pull/353));
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index a1098cbb..9410f205 100644
--- a/build.gradle
+++ b/build.gradle
@@ -45,7 +45,7 @@ allprojects {
 	defaultTasks "build"
 
 	ext {
-        isSnapshot = true
+        isSnapshot = false
         fjBaseVersion = "4.8"
 
         snapshotAppendix = "-SNAPSHOT"
@@ -53,7 +53,7 @@ allprojects {
         fjConsumeVersion = "4.7"
 
         signModule = false
-        useRetroLambda = false
+        useRetroLambda = true
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"

From 8cce3ee2d3c221a67b06e48f616532ecfa58b122 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 18 Aug 2018 23:29:19 +0200
Subject: [PATCH 209/336] Update readme. Prepare next iteration.

---
 README.adoc  | 18 +++++++++---------
 build.gradle | 10 +++++-----
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/README.adoc b/README.adoc
index 6c5d3c1e..a7e2d3a4 100644
--- a/README.adoc
+++ b/README.adoc
@@ -35,12 +35,12 @@ The Functional Java artifact is published to Maven Central using the group `org.
 * Java 8 specific support (`functionaljava-java8`)
 * property based testing (`functionaljava-quickcheck` or `functionaljava-quickcheck_1.8` if you use Java 8+)
 
-The latest stable version is `4.7`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `4.8`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.7"
-compile "org.functionaljava:functionaljava-java8:4.7"
-compile "org.functionaljava:functionaljava-quickcheck:4.7"
-compile "org.functionaljava:functionaljava-java-core:4.7"
+compile "org.functionaljava:functionaljava:4.8"
+compile "org.functionaljava:functionaljava-java8:4.8"
+compile "org.functionaljava:functionaljava-quickcheck:4.8"
+compile "org.functionaljava:functionaljava-java-core:4.8"
 ----
 
 and in Maven:
@@ -48,22 +48,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.7</version>
+    <version>4.8</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java8</artifactId>
-    <version>4.7</version>
+    <version>4.8</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.7</version>
+    <version>4.8</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java-core</artifactId>
-    <version>4.7</version>
+    <version>4.8</version>
 </dependency>
 ----
 
diff --git a/build.gradle b/build.gradle
index 9410f205..fe81f484 100644
--- a/build.gradle
+++ b/build.gradle
@@ -44,16 +44,16 @@ allprojects {
 
 	defaultTasks "build"
 
-	ext {
-        isSnapshot = false
-        fjBaseVersion = "4.8"
+    ext {
+        isSnapshot = true
+        fjBaseVersion = "4.9"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.7"
+        fjConsumeVersion = "4.8"
 
         signModule = false
-        useRetroLambda = true
+        useRetroLambda = false
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"

From fd9b337abe0927bc8d2f5b149198bc84a77c0b46 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 18 Aug 2018 18:23:40 -0400
Subject: [PATCH 210/336] Add Visitor tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 .../test/java/fj/function/VisitorTest.java    | 80 +++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 core/src/test/java/fj/function/VisitorTest.java

diff --git a/core/src/test/java/fj/function/VisitorTest.java b/core/src/test/java/fj/function/VisitorTest.java
new file mode 100644
index 00000000..54efcf24
--- /dev/null
+++ b/core/src/test/java/fj/function/VisitorTest.java
@@ -0,0 +1,80 @@
+package fj.function;
+
+import fj.Equal;
+import fj.F;
+import fj.P;
+import fj.P1;
+import fj.data.List;
+import org.junit.Test;
+
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+import static fj.function.Visitor.*;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class VisitorTest {
+    @Test
+    public void testFindFirst() {
+        assertThat(findFirst(List.list(none(), some(1), none()), () -> -1), is(1));
+    }
+
+    @Test
+    public void testFindFirstDef() {
+        assertThat(findFirst(List.list(none(), none(), none()), () -> -1), is(-1));
+    }
+
+    @Test
+    public void testNullableFindFirst() {
+        assertThat(nullablefindFirst(List.list(null, 1, null), () -> -1), is(1));
+    }
+
+    @Test
+    public void testNullableFindFirstDef() {
+        assertThat(nullablefindFirst(List.list(null, null, null), () -> -1), is(-1));
+    }
+
+    @Test
+    public void testVisitor() {
+        assertThat(visitor(List.list(i -> some(2 * i)), () -> -1, 10), is(20));
+    }
+
+    @Test
+    public void testVisitorDef() {
+        assertThat(visitor(List.list(i -> none()), () -> "foo", 10), is("foo"));
+    }
+
+    @Test
+    public void testNullableVisitor() {
+        assertThat(nullableVisitor(List.list(i -> 2 * i), () -> -1, 10), is(20));
+    }
+
+    @Test
+    public void testNullableVisitorDef() {
+        assertThat(nullableVisitor(List.list(i -> null), () -> "foo", 10), is("foo"));
+    }
+
+    @Test
+    public void testAssociation() {
+        final F<String, F<Integer, String>> a = association(List.list(P.p(1, "one"), P.p(2, "two")), Equal.intEqual);
+        assertThat(a.f("foo").f(2), is("two"));
+    }
+
+    @Test
+    public void testAssociationDef() {
+        final F<String, F<Integer, String>> a = association(List.list(P.p(1, "one"), P.p(2, "two")), Equal.intEqual);
+        assertThat(a.f("foo").f(3), is("foo"));
+    }
+
+    @Test
+    public void testAssociationLazy() {
+        final F<P1<String>, F<Integer, String>> a = associationLazy(List.list(P.p(1, "one"), P.p(2, "two")), Equal.intEqual);
+        assertThat(a.f(P.p("foo")).f(2), is("two"));
+    }
+
+    @Test
+    public void testAssociationLazyDef() {
+        final F<P1<String>, F<Integer, String>> a = associationLazy(List.list(P.p(1, "one"), P.p(2, "two")), Equal.intEqual);
+        assertThat(a.f(P.p("foo")).f(3), is("foo"));
+    }
+}

From f1801d3c4fa3b8c8bdfddd185b7e20bb4ce65860 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 20 Aug 2018 20:01:15 -0400
Subject: [PATCH 211/336] Add DList tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/data/DListTest.java | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 core/src/test/java/fj/data/DListTest.java

diff --git a/core/src/test/java/fj/data/DListTest.java b/core/src/test/java/fj/data/DListTest.java
new file mode 100644
index 00000000..6846ca2d
--- /dev/null
+++ b/core/src/test/java/fj/data/DListTest.java
@@ -0,0 +1,31 @@
+package fj.data;
+
+import org.junit.Test;
+
+import static fj.data.DList.*;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class DListTest {
+    @Test
+    public void testConsSnoc() {
+        assertThat(nil().snoc(2).cons(1).toJavaList(), is(single(1).snoc(2).toJavaList()));
+    }
+
+    @Test
+    public void testListDList() {
+        DList<Integer> d = listDList(List.range(0, 1000));
+        assertThat(d.toJavaList(), is(List.range(0, 1000).toJavaList()));
+    }
+
+    @Test
+    public void testArrayDList() {
+        DList<Integer> d = arrayDList(Array.range(0, 1000).array(Integer[].class));
+        assertThat(d.toJavaList(), is(Array.range(0, 1000).toJavaList()));
+    }
+    @Test
+    public void testIter() {
+        DList<Integer> d = iteratorDList(List.range(0, 1000).iterator());
+        assertThat(d.toJavaList(), is(List.range(0, 1000).toJavaList()));
+    }
+}

From 58e0b4b556b870507dc6d7b788101b60f328f8b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Thu, 23 Aug 2018 10:05:41 -0400
Subject: [PATCH 212/336] Exclude consume/ from coverage

---
 codecov.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/codecov.yml b/codecov.yml
index 8c7fd5e4..b7ddeec5 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -1,3 +1,4 @@
 ignore:
   - "demo/.*"
-  - "performance/.*"
\ No newline at end of file
+  - "consume/.*"
+  - "performance/.*"

From 33d5e8338f9c6a90a44882e61e821632be996990 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Mon, 27 Aug 2018 21:25:41 -0400
Subject: [PATCH 213/336] Add P tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/test/java/fj/PTest.java | 159 +++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 core/src/test/java/fj/PTest.java

diff --git a/core/src/test/java/fj/PTest.java b/core/src/test/java/fj/PTest.java
new file mode 100644
index 00000000..2a97303f
--- /dev/null
+++ b/core/src/test/java/fj/PTest.java
@@ -0,0 +1,159 @@
+package fj;
+
+import org.junit.Test;
+
+import static fj.Function.identity;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class PTest {
+    @Test
+    public void testPF(){
+        final F<Integer, P1<Integer>> p1f = P.p1();
+        final P1<Integer> p1 = p1f.f(1);
+        F<Integer, F<Integer, P2<Integer, Integer>>> p2f = P.p2();
+        final P2<Integer, Integer> p2 = p2f.f(1).f(2);
+        assertThat(P2.<Integer,Integer>__1().f(p2), is(P1.<Integer>__1().f(p1)));
+        final F<Integer, F<Integer, F<Integer, P3<Integer, Integer, Integer>>>> p3f = P.p3();
+        final P3<Integer, Integer, Integer> p3 = p3f.f(1).f(2).f(3);
+        assertThat(P3.<Integer,Integer, Integer>__1().f(p3), is(P2.<Integer,Integer>__1().f(p2)));
+        assertThat(P3.<Integer,Integer, Integer>__2().f(p3), is(P2.<Integer,Integer>__2().f(p2)));
+        final F<Integer, F<Integer, F<Integer, F<Integer, P4<Integer, Integer, Integer, Integer>>>>> p4f = P.p4();
+        final P4<Integer, Integer, Integer, Integer> p4 = p4f.f(1).f(2).f(3).f(4);
+        assertThat(P4.<Integer,Integer,Integer,Integer>__1().f(p4), is(P3.<Integer,Integer,Integer>__1().f(p3)));
+        assertThat(P4.<Integer,Integer,Integer,Integer>__2().f(p4), is(P3.<Integer,Integer,Integer>__2().f(p3)));
+        assertThat(P4.<Integer,Integer,Integer,Integer>__3().f(p4), is(P3.<Integer,Integer,Integer>__3().f(p3)));
+        final F<Integer, F<Integer, F<Integer, F<Integer, F<Integer, P5<Integer, Integer, Integer, Integer, Integer>>>>>> p5f = P.p5();
+        final P5<Integer, Integer, Integer, Integer, Integer> p5 = p5f.f(1).f(2).f(3).f(4).f(5);
+        assertThat(P5.<Integer,Integer,Integer,Integer,Integer>__1().f(p5), is(P4.<Integer,Integer,Integer,Integer>__1().f(p4)));
+        assertThat(P5.<Integer,Integer,Integer,Integer,Integer>__2().f(p5), is(P4.<Integer,Integer,Integer,Integer>__2().f(p4)));
+        assertThat(P5.<Integer,Integer,Integer,Integer,Integer>__3().f(p5), is(P4.<Integer,Integer,Integer,Integer>__3().f(p4)));
+        assertThat(P5.<Integer,Integer,Integer,Integer,Integer>__4().f(p5), is(P4.<Integer,Integer,Integer,Integer>__4().f(p4)));
+        final F<Integer, F<Integer, F<Integer, F<Integer, F<Integer, F<Integer,
+                P6<Integer, Integer, Integer, Integer, Integer, Integer>>>>>>> p6f = P.p6();
+        final P6<Integer, Integer, Integer, Integer, Integer, Integer> p6 = p6f.f(1).f(2).f(3).f(4).f(5).f(6);
+        assertThat(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__1().f(p6),
+                is(P5.<Integer,Integer,Integer,Integer,Integer>__1().f(p5)));
+        assertThat(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__2().f(p6),
+                is(P5.<Integer,Integer,Integer,Integer,Integer>__2().f(p5)));
+        assertThat(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__3().f(p6),
+                is(P5.<Integer,Integer,Integer,Integer,Integer>__3().f(p5)));
+        assertThat(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__4().f(p6),
+                is(P5.<Integer,Integer,Integer,Integer,Integer>__4().f(p5)));
+        assertThat(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__5().f(p6),
+                is(P5.<Integer,Integer,Integer,Integer,Integer>__5().f(p5)));
+        final F<Integer, F<Integer, F<Integer, F<Integer, F<Integer, F<Integer, F<Integer,
+                P7<Integer, Integer, Integer, Integer, Integer, Integer, Integer>>>>>>>> p7f = P.p7();
+        final P7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> p7 =
+                p7f.f(1).f(2).f(3).f(4).f(5).f(6).f(7);
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__1().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__1().f(p6)));
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__2().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__2().f(p6)));
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__3().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__3().f(p6)));
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__4().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__4().f(p6)));
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__5().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__5().f(p6)));
+        assertThat(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__6().f(p7),
+                is(P6.<Integer,Integer,Integer,Integer,Integer,Integer>__6().f(p6)));
+        final F<Integer, F<Integer, F<Integer, F<Integer, F<Integer, F<Integer,
+                F<Integer, F<Integer, P8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>>>>>>>>> p8f = P.p8();
+        final P8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> p8 =
+                p8f.f(1).f(2).f(3).f(4).f(5).f(6).f(7).f(8);
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__1().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__1().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__2().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__2().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__3().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__3().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__4().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__4().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__5().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__5().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__6().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__6().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__7().f(p8),
+                is(P7.<Integer,Integer,Integer,Integer,Integer,Integer,Integer>__7().f(p7)));
+        assertThat(P8.<Integer,Integer,Integer,Integer,Integer,Integer,Integer,Integer>__8().f(p8), is(8));
+    }
+
+    @Test
+    public void testPProject1() {
+        final P1<Integer> p1 = P.p(1);
+        assertThat(p1.map(identity()), is(p1));
+    }
+
+    @Test
+    public void testPProject2() {
+        final P2<Integer, Integer> p2 = P.p(1, 2);
+        assertThat(p2.map1(identity()), is(p2));
+        assertThat(p2.map2(identity()), is(p2));
+    }
+
+    @Test
+    public void testPProject3() {
+        final P3<Integer, Integer, Integer> p3 = P.p(1, 2, 3);
+        assertThat(p3.map1(identity()), is(p3));
+        assertThat(p3.map2(identity()), is(p3));
+        assertThat(p3.map3(identity()), is(p3));
+    }
+
+    @Test
+    public void testPProject4() {
+        final P4<Integer, Integer, Integer, Integer> p4 = P.p(1, 2, 3, 4);
+        assertThat(p4.map1(identity()), is(p4));
+        assertThat(p4.map2(identity()), is(p4));
+        assertThat(p4.map3(identity()), is(p4));
+        assertThat(p4.map4(identity()), is(p4));
+    }
+
+    @Test
+    public void testPProject5() {
+        final P5<Integer, Integer, Integer, Integer, Integer> p5 = P.p(1, 2, 3, 4, 5);
+        assertThat(p5.map1(identity()), is(p5));
+        assertThat(p5.map2(identity()), is(p5));
+        assertThat(p5.map3(identity()), is(p5));
+        assertThat(p5.map4(identity()), is(p5));
+        assertThat(p5.map5(identity()), is(p5));
+    }
+
+    @Test
+    public void testPProject6() {
+        final P6<Integer, Integer, Integer, Integer, Integer, Integer> p6 = P.p(1, 2, 3, 4, 5, 6);
+        assertThat(p6.map1(identity()), is(p6));
+        assertThat(p6.map2(identity()), is(p6));
+        assertThat(p6.map3(identity()), is(p6));
+        assertThat(p6.map4(identity()), is(p6));
+        assertThat(p6.map5(identity()), is(p6));
+        assertThat(p6.map6(identity()), is(p6));
+    }
+
+    @Test
+    public void testPProject7() {
+        final P7<Integer, Integer, Integer, Integer, Integer, Integer, Integer> p7 =
+                P.p(1, 2, 3, 4, 5, 6, 7);
+        assertThat(p7.map1(identity()), is(p7));
+        assertThat(p7.map2(identity()), is(p7));
+        assertThat(p7.map3(identity()), is(p7));
+        assertThat(p7.map4(identity()), is(p7));
+        assertThat(p7.map5(identity()), is(p7));
+        assertThat(p7.map6(identity()), is(p7));
+        assertThat(p7.map7(identity()), is(p7));
+    }
+
+    @Test
+    public void testPProject8() {
+        final P8<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer> p8 =
+                P.p(1, 2, 3, 4, 5, 6, 7, 8);
+        assertThat(p8.map1(identity()), is(p8));
+        assertThat(p8.map2(identity()), is(p8));
+        assertThat(p8.map3(identity()), is(p8));
+        assertThat(p8.map4(identity()), is(p8));
+        assertThat(p8.map5(identity()), is(p8));
+        assertThat(p8.map6(identity()), is(p8));
+        assertThat(p8.map7(identity()), is(p8));
+        assertThat(p8.map8(identity()), is(p8));
+    }
+}

From ebdceaa7653780d8c896ad08687a22b934538aa5 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 25 Aug 2018 21:16:44 +0200
Subject: [PATCH 214/336] Fix compile under jdk11. Enable jdk11 travis build.

---
 .travis.yml                                   |  21 +-
 build.gradle                                  |  13 +-
 core/src/main/java/fj/data/$.java             |   6 -
 core/src/main/java/fj/data/IOFunctions.java   | 234 +++++++++---------
 core/src/main/java/fj/data/Java.java          |  22 +-
 core/src/main/java/fj/data/TreeZipper.java    |  17 +-
 demo/build.gradle                             |   2 +-
 gradle/wrapper/gradle-wrapper.properties      |   3 +-
 java-core/build.gradle                        |   2 +-
 props-core-scalacheck/build.gradle            |   4 +-
 .../src/main/java/fj/test/Arbitrary.java      | 174 +++++--------
 quickcheck/src/main/java/fj/test/Arg.java     |   9 +-
 .../src/main/java/fj/test/CheckResult.java    |  18 +-
 quickcheck/src/main/java/fj/test/Cogen.java   |   7 +-
 quickcheck/src/main/java/fj/test/Gen.java     |   2 +-
 .../src/main/java/fj/test/Property.java       |  30 +--
 quickcheck/src/main/java/fj/test/Shrink.java  |   5 +-
 .../src/main/java/fj/test/reflect/Check.java  |   8 +-
 .../java/fj/test/reflect/CheckParams.java     |   1 +
 .../src/main/java/fj/test/reflect/Main.java   |   3 -
 .../fj/test/runner/PropertyTestRunner.java    |   9 +-
 .../src/test/java/fj/data/test/TestCheck.java |  12 +-
 .../src/test/java/fj/data/test/TestNull.java  |  10 +-
 quickcheck/src/test/java/fj/test/GenTest.java |  18 +-
 24 files changed, 247 insertions(+), 383 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 539e7a45..7c55b120 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,17 +4,22 @@ sudo: false
 language: java
 
 jdk:
-  - oraclejdk8
+ - openjdk11
+
+matrix:
+
+  include:
+  - jdk: openjdk8
+    script:
+      - ./gradlew build coverage -s -i
+    after_success:
+      - bash <(curl -s https://codecov.io/bash)
+      - '[ "$TRAVIS_BRANCH" = "series/4.x" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
+        && ./gradlew uploadArchives'
 
 script:
-  - jdk_switcher use openjdk7 && export JAVA7_HOME=$JAVA_HOME
-  - jdk_switcher use oraclejdk8 && export JAVA8_HOME=$JAVA_HOME
-  - ./gradlew build coverage -s -i
+  - ./gradlew clean test
 
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
-  - '[ "$TRAVIS_BRANCH" = "master" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
-  && ./gradlew uploadArchives'
 
 env:
   global:
diff --git a/build.gradle b/build.gradle
index fe81f484..9d98d2b3 100644
--- a/build.gradle
+++ b/build.gradle
@@ -23,8 +23,6 @@ buildscript {
     }
 }
 
-apply plugin: "jacoco"
-
 if (JavaVersion.current().isJava8Compatible()) {
     allprojects {
         tasks.withType(Javadoc) {
@@ -35,11 +33,10 @@ if (JavaVersion.current().isJava8Compatible()) {
 
 allprojects {
 
-
+    apply plugin: "jacoco"
 
     jacoco {
-        toolVersion = "0.8.1"
-
+        toolVersion = "0.8.2"
     }
 
 	defaultTasks "build"
@@ -100,8 +97,6 @@ subprojects {
         }
     }
 
-    apply plugin: "jacoco"
-
     apply from: "$rootDir/lib.gradle"
 	apply plugin: "java"
 	apply plugin: "eclipse"
@@ -123,9 +118,13 @@ subprojects {
 	}
 
     jacocoTestReport {
+        additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
+        sourceDirectories = files(sourceSets.main.allSource.srcDirs)
+        classDirectories =  files(sourceSets.main.output)
         reports {
             html.enabled = true
             xml.enabled = true
+            csv.enabled = false
         }
     }
 
diff --git a/core/src/main/java/fj/data/$.java b/core/src/main/java/fj/data/$.java
index 17b2ac9e..a1aa77bf 100644
--- a/core/src/main/java/fj/data/$.java
+++ b/core/src/main/java/fj/data/$.java
@@ -17,14 +17,8 @@ public final class $<A, B> extends P1<B> {
 
   /**
    * Returns a function that given an argument, returns a function that ignores its argument.
-   * @deprecated  JDK 8 warns '_' may not be supported after SE 8.  As of release 4.4, use {@link #constant} (note the synonym {@link #__}).
    * @return A function that given an argument, returns a function that ignores its argument.
    */
-  @Deprecated
-  public static <A, B> $<A, B> _(final B b) {
-    return constant(b);
-  }
-
 	public static <A, B> $<A, B> __(final B b) {
 		return constant(b);
 	}
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 92263d09..2ea15dfb 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -1,8 +1,19 @@
 package fj.data;
 
-import static fj.Bottom.errorF;
-import static fj.Function.constant;
-import static fj.Function.partialApply2;
+import fj.F;
+import fj.F0;
+import fj.F1Functions;
+import fj.F2;
+import fj.Function;
+import fj.P;
+import fj.P1;
+import fj.P2;
+import fj.Try;
+import fj.Unit;
+import fj.data.Iteratee.Input;
+import fj.data.Iteratee.IterV;
+import fj.function.Try0;
+import fj.function.Try1;
 
 import java.io.BufferedReader;
 import java.io.Closeable;
@@ -14,11 +25,9 @@
 import java.nio.charset.Charset;
 import java.util.Arrays;
 
-import fj.*;
-import fj.data.Iteratee.Input;
-import fj.data.Iteratee.IterV;
-import fj.function.Try0;
-import fj.function.Try1;
+import static fj.Bottom.errorF;
+import static fj.Function.constant;
+import static fj.Function.partialApply2;
 
 /**
  * IO monad for processing files, with main methods {@link #enumFileLines },
@@ -170,38 +179,37 @@ public static <A> SafeIO<A> lazySafe(final F0<A> f) {
      * A function that feeds an iteratee with lines read from a {@link BufferedReader}.
      */
     public static <A> F<BufferedReader, F<IterV<String, A>, IO<IterV<String, A>>>> lineReader() {
-        final F<IterV<String, A>, Boolean> isDone =
-                new F<Iteratee.IterV<String, A>, Boolean>() {
-                    final F<P2<A, Input<String>>, P1<Boolean>> done = constant(P.p(true));
-                    final F<F<Input<String>, IterV<String, A>>, P1<Boolean>> cont = constant(P.p(false));
-
-                    @Override
-                    public Boolean f(final IterV<String, A> i) {
-                        return i.fold(done, cont)._1();
-                    }
-                };
-
-        return r -> new F<IterV<String, A>, IO<IterV<String, A>>>() {
-            final F<P2<A, Input<String>>, P1<IterV<String, A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
-
-            @Override
-            public IO<IterV<String, A>> f(final IterV<String, A> it) {
-                // use loop instead of recursion because of missing TCO
-                return () -> {
-                    IterV<String, A> i = it;
-                    while (!isDone.f(i)) {
-                        final String s = r.readLine();
-                        if (s == null) {
-                            return i;
-                        }
-                        final Input<String> input = Input.el(s);
-                        final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.apply(input));
-                        i = i.fold(done, cont)._1();
+        return LineReader::new;
+    }
+
+    private static class LineReader<A> implements F<IterV<String, A>, IO<IterV<String, A>>> {
+
+        private final BufferedReader r;
+
+        private final F<IterV<String, A>, Boolean> isDone = i -> i.fold(constant(P.p(true)), constant(P.p(false)))._1();
+        private final F<P2<A, Input<String>>, P1<IterV<String, A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
+
+        private LineReader(BufferedReader r) {
+            this.r = r;
+        }
+
+        @Override
+        public IO<IterV<String, A>> f(IterV<String, A> it) {
+            // use loop instead of recursion because of missing TCO
+            return () -> {
+                IterV<String, A> i = it;
+                while (!isDone.f(i)) {
+                    final String s = r.readLine();
+                    if (s == null) {
+                        return i;
                     }
-                    return i;
-                };
-            }
-        };
+                    final Input<String> input = Input.el(s);
+                    final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.apply(input));
+                    i = i.fold(done, cont)._1();
+                }
+                return i;
+            };
+        }
     }
 
     /**
@@ -209,91 +217,91 @@ public IO<IterV<String, A>> f(final IterV<String, A> it) {
      * (char[] of size {@link #DEFAULT_BUFFER_SIZE}).
      */
     public static <A> F<Reader, F<IterV<char[], A>, IO<IterV<char[], A>>>> charChunkReader() {
-        final F<IterV<char[], A>, Boolean> isDone =
-                new F<Iteratee.IterV<char[], A>, Boolean>() {
-                    final F<P2<A, Input<char[]>>, P1<Boolean>> done = constant(P.p(true));
-                    final F<F<Input<char[]>, IterV<char[], A>>, P1<Boolean>> cont = constant(P.p(false));
-
-                    @Override
-                    public Boolean f(final IterV<char[], A> i) {
-                        return i.fold(done, cont)._1();
+        return CharChunkReader::new;
+    }
+
+    private static class CharChunkReader<A> implements F<IterV<char[], A>, IO<IterV<char[], A>>> {
+
+        private final Reader r;
+
+        private final F<IterV<char[], A>, Boolean> isDone = i -> i.fold(constant(P.p(true)), constant(P.p(false)))._1();
+        private final F<P2<A, Input<char[]>>, P1<IterV<char[], A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
+
+        CharChunkReader(Reader r) {
+            this.r = r;
+        }
+
+        @Override
+        public IO<IterV<char[], A>> f(IterV<char[], A> it) {
+            // use loop instead of recursion because of missing TCO
+            return () -> {
+
+                IterV<char[], A> i = it;
+                while (!isDone.f(i)) {
+                    char[] buffer = new char[DEFAULT_BUFFER_SIZE];
+                    final int numRead = r.read(buffer);
+                    if (numRead == -1) {
+                        return i;
                     }
-                };
-
-        return r -> new F<IterV<char[], A>, IO<IterV<char[], A>>>() {
-            final F<P2<A, Input<char[]>>, P1<IterV<char[], A>>> done = errorF("iteratee is done"); //$NON-NLS-1$
-
-            @Override
-            public IO<IterV<char[], A>> f(final IterV<char[], A> it) {
-                // use loop instead of recursion because of missing TCO
-                return () -> {
-
-                    IterV<char[], A> i = it;
-                    while (!isDone.f(i)) {
-                        char[] buffer = new char[DEFAULT_BUFFER_SIZE];
-                        final int numRead = r.read(buffer);
-                        if (numRead == -1) {
-                            return i;
-                        }
-                        if (numRead < buffer.length) {
-                            buffer = Arrays.copyOfRange(buffer, 0, numRead);
-                        }
-                        final Input<char[]> input = Input.el(buffer);
-                        final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
-                                F1Functions.lazy(Function.apply(input));
-                        i = i.fold(done, cont)._1();
+                    if (numRead < buffer.length) {
+                        buffer = Arrays.copyOfRange(buffer, 0, numRead);
                     }
-                    return i;
-                };
-            }
-        };
+                    final Input<char[]> input = Input.el(buffer);
+                    final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
+                        F1Functions.lazy(Function.apply(input));
+                    i = i.fold(done, cont)._1();
+                }
+                return i;
+            };
+        }
     }
 
+
+
     /**
      * A function that feeds an iteratee with characters read from a {@link Reader}
      * (chars are read in chunks of size {@link #DEFAULT_BUFFER_SIZE}).
      */
     public static <A> F<Reader, F<IterV<Character, A>, IO<IterV<Character, A>>>> charChunkReader2() {
-        final F<IterV<Character, A>, Boolean> isDone =
-                new F<Iteratee.IterV<Character, A>, Boolean>() {
-                    final F<P2<A, Input<Character>>, P1<Boolean>> done = constant(P.p(true));
-                    final F<F<Input<Character>, IterV<Character, A>>, P1<Boolean>> cont = constant(P.p(false));
-
-                    @Override
-                    public Boolean f(final IterV<Character, A> i) {
-                        return i.fold(done, cont)._1();
+        return CharChunkReader2::new;
+    }
+
+    private static class CharChunkReader2<A> implements F<IterV<Character, A>, IO<IterV<Character, A>>> {
+
+        private final Reader r;
+
+        private final F<IterV<Character, A>, Boolean> isDone = i -> i.fold(constant(P.p(true)), constant(P.p(false)))._1();
+        private final F<P2<A, Input<Character>>, IterV<Character, A>> done = errorF("iteratee is done"); //$NON-NLS-1$
+
+        CharChunkReader2(Reader r) {
+            this.r = r;
+        }
+
+        @Override
+        public IO<IterV<Character, A>> f(IterV<Character, A> it) {
+            // use loop instead of recursion because of missing TCO
+            return () -> {
+
+                IterV<Character, A> i = it;
+                while (!isDone.f(i)) {
+                    char[] buffer = new char[DEFAULT_BUFFER_SIZE];
+                    final int numRead = r.read(buffer);
+                    if (numRead == -1) {
+                        return i;
                     }
-                };
-
-        return r -> new F<IterV<Character, A>, IO<IterV<Character, A>>>() {
-            final F<P2<A, Input<Character>>, IterV<Character, A>> done = errorF("iteratee is done"); //$NON-NLS-1$
-
-            @Override
-            public IO<IterV<Character, A>> f(final IterV<Character, A> it) {
-                // use loop instead of recursion because of missing TCO
-                return () -> {
-
-                    IterV<Character, A> i = it;
-                    while (!isDone.f(i)) {
-                        char[] buffer = new char[DEFAULT_BUFFER_SIZE];
-                        final int numRead = r.read(buffer);
-                        if (numRead == -1) {
-                            return i;
-                        }
-                        if (numRead < buffer.length) {
-                            buffer = Arrays.copyOfRange(buffer, 0, numRead);
-                        }
-                        for (char c : buffer) {
-                            final Input<Character> input = Input.el(c);
-                            final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
-                                Function.apply(input);
-                            i = i.fold(done, cont);
-                        }
+                    if (numRead < buffer.length) {
+                        buffer = Arrays.copyOfRange(buffer, 0, numRead);
                     }
-                    return i;
-                };
-            }
-        };
+                    for (char c : buffer) {
+                        final Input<Character> input = Input.el(c);
+                        final F<F<Input<Character>, IterV<Character, A>>, IterV<Character, A>> cont =
+                            Function.apply(input);
+                        i = i.fold(done, cont);
+                    }
+                }
+                return i;
+            };
+        }
     }
 
     public static <A, B> IO<B> map(final IO<A> io, final F<A, B> f) {
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 487e9703..80a5ec43 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -404,27 +404,7 @@ public static <A> F<Array<A>, SynchronousQueue<A>> Array_SynchronousQueue(final
    * @return A function that converts streams to iterable.
    */
   public static <A> F<Stream<A>, Iterable<A>> Stream_Iterable() {
-    return as -> () -> new Iterator<A>() {
-      private Stream<A> x = as;
-
-      public boolean hasNext() {
-        return x.isNotEmpty();
-      }
-
-      public A next() {
-        if (x.isEmpty())
-          throw new NoSuchElementException("Empty iterator");
-        else {
-          final A a = x.head();
-          x = x.tail()._1();
-          return a;
-        }
-      }
-
-      public void remove() {
-        throw new UnsupportedOperationException();
-      }
-    };
+    return as -> as;
   }
 
   /**
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index 46392d20..9ffad4f4 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -628,21 +628,8 @@ private Stream<Tree<TreeZipper<A>>> uf(final F<TreeZipper<A>, Option<TreeZipper<
   }
 
   private static <A> F<TreeZipper<A>, P2<TreeZipper<A>, P1<Stream<TreeZipper<A>>>>> dwn() {
-    return tz -> P.p(tz, new P1<Stream<TreeZipper<A>>>() {
-      private F<Option<TreeZipper<A>>, Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>>> fwd() {
-        return o -> {
-          Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>> r = none();
-          for (final TreeZipper<A> c : o) {
-            r = some(P.p(c, c.right()));
-          }
-          return r;
-        };
-      }
-
-      public Stream<TreeZipper<A>> _1() {
-        return unfold(fwd(), tz.firstChild());
-      }
-    });
+    F<Option<TreeZipper<A>>, Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>>> fwd = o -> o.map(c -> P.p(c, c.right()));
+    return tz -> P.p(tz, P.lazy(() -> unfold(fwd, tz.firstChild())));
   }
 
   /**
diff --git a/demo/build.gradle b/demo/build.gradle
index 41841cfa..b79cb246 100644
--- a/demo/build.gradle
+++ b/demo/build.gradle
@@ -17,4 +17,4 @@ test {
     jacoco {
         enabled = false
     }
-}
\ No newline at end of file
+}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 717f0389..72c40576 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,6 @@
+#Sat Aug 25 14:20:05 CEST 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-all.zip
diff --git a/java-core/build.gradle b/java-core/build.gradle
index 3b636072..b5ee71ec 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -16,4 +16,4 @@ configureUpload(signingEnabled, signModule)
 
 uploadArchives.enabled = true
 
-configureAllRetroLambda()
\ No newline at end of file
+configureAllRetroLambda()
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index a395a586..10e494c9 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -4,7 +4,7 @@ archivesBaseName = "${project.projectName}-${project.name}"
 apply plugin: 'scala'
 
 ext {
-    scalaVersion = "2.11.11"
+    scalaVersion = "2.11.12"
     scalacheckScalaVersion = "2.11"
     scalacheckVersion = "1.12.6"
     signModule = true
@@ -20,5 +20,3 @@ dependencies {
 
 performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)
-
-
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index df922af2..95bdedca 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -1,8 +1,6 @@
 package fj.test;
 
-import fj.Equal;
 import fj.F;
-import fj.F1Functions;
 import fj.F2;
 import fj.F3;
 import fj.F4;
@@ -13,7 +11,6 @@
 import fj.Function;
 import fj.Bottom;
 
-import static fj.Equal.longEqual;
 import static fj.Function.compose;
 import static fj.P.p;
 
@@ -30,22 +27,14 @@
 import fj.LcgRng;
 import fj.Ord;
 
-import static fj.data.Either.left;
-import static fj.data.Either.right;
 import static fj.data.Enumerator.charEnumerator;
 import static fj.data.List.asString;
 import static fj.data.List.list;
-import static fj.data.Option.some;
 
 import fj.data.List;
 import fj.data.Set;
-import fj.data.TreeMap;
-import fj.function.Booleans;
-import fj.function.Effect1;
-import fj.function.Longs;
 
 import static fj.data.Stream.range;
-import static fj.function.Booleans.not;
 import static fj.test.Gen.choose;
 import static fj.test.Gen.elements;
 import static fj.test.Gen.fail;
@@ -95,11 +84,7 @@ public final class Arbitrary {
    * @return An arbitrary for functions.
    */
   public static <A, B> Gen<F<A, B>> arbF(final Cogen<A> c, final Gen<B> a) {
-    return promote(new F<A, Gen<B>>() {
-      public Gen<B> f(final A x) {
-        return c.cogen(x, a);
-      }
-    });
+    return promote(x -> c.cogen(x, a));
   }
 
     public static <A, B> Gen<Reader<A, B>> arbReader(Cogen<A> aa, Gen<B> ab) {
@@ -389,19 +374,14 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
    * max, min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link
    * #arbInteger} the remainder of the time (93%).
    */
-  public static final Gen<Integer> arbIntegerBoundaries = sized(new F<Integer, Gen<Integer>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Integer> f(final Integer i) {
-      return frequency(list(p(1, value(0)),
-                            p(1, value(1)),
-                            p(1, value(-1)),
-                            p(1, value(Integer.MAX_VALUE)),
-                            p(1, value(Integer.MIN_VALUE)),
-                            p(1, value(Integer.MAX_VALUE - 1)),
-                            p(1, value(Integer.MIN_VALUE + 1)),
-                            p(93, arbInteger)));
-    }
-  });
+  public static final Gen<Integer> arbIntegerBoundaries = sized(i -> frequency(list(p(1, value(0)),
+                        p(1, value(1)),
+                        p(1, value(-1)),
+                        p(1, value(Integer.MAX_VALUE)),
+                        p(1, value(Integer.MIN_VALUE)),
+                        p(1, value(Integer.MAX_VALUE - 1)),
+                        p(1, value(Integer.MIN_VALUE + 1)),
+                        p(93, arbInteger))));
 
   /**
    * An arbitrary implementation for long values.
@@ -414,19 +394,14 @@ public Gen<Integer> f(final Integer i) {
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbLong}
    * the remainder of the time (93%).
    */
-  public static final Gen<Long> arbLongBoundaries = sized(new F<Integer, Gen<Long>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Long> f(final Integer i) {
-      return frequency(list(p(1, value(0L)),
-                            p(1, value(1L)),
-                            p(1, value(-1L)),
-                            p(1, value(Long.MAX_VALUE)),
-                            p(1, value(Long.MIN_VALUE)),
-                            p(1, value(Long.MAX_VALUE - 1L)),
-                            p(1, value(Long.MIN_VALUE + 1L)),
-                            p(93, arbLong)));
-    }
-  });
+  public static final Gen<Long> arbLongBoundaries = sized(i -> frequency(list(p(1, value(0L)),
+                        p(1, value(1L)),
+                        p(1, value(-1L)),
+                        p(1, value(Long.MAX_VALUE)),
+                        p(1, value(Long.MIN_VALUE)),
+                        p(1, value(Long.MAX_VALUE - 1L)),
+                        p(1, value(Long.MIN_VALUE + 1L)),
+                        p(93, arbLong))));
 
   /**
    * An arbitrary implementation for byte values.
@@ -438,19 +413,14 @@ public Gen<Long> f(final Integer i) {
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbByte}
    * the remainder of the time (93%).
    */
-  public static final Gen<Byte> arbByteBoundaries = sized(new F<Integer, Gen<Byte>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Byte> f(final Integer i) {
-      return frequency(list(p(1, value((byte) 0)),
-                            p(1, value((byte) 1)),
-                            p(1, value((byte) -1)),
-                            p(1, value(Byte.MAX_VALUE)),
-                            p(1, value(Byte.MIN_VALUE)),
-                            p(1, value((byte) (Byte.MAX_VALUE - 1))),
-                            p(1, value((byte) (Byte.MIN_VALUE + 1))),
-                            p(93, arbByte)));
-    }
-  });
+  public static final Gen<Byte> arbByteBoundaries = sized(i -> frequency(list(p(1, value((byte) 0)),
+                        p(1, value((byte) 1)),
+                        p(1, value((byte) -1)),
+                        p(1, value(Byte.MAX_VALUE)),
+                        p(1, value(Byte.MIN_VALUE)),
+                        p(1, value((byte) (Byte.MAX_VALUE - 1))),
+                        p(1, value((byte) (Byte.MIN_VALUE + 1))),
+                        p(93, arbByte))));
 
   /**
    * An arbitrary implementation for short values.
@@ -462,19 +432,14 @@ public Gen<Byte> f(final Integer i) {
    * min, max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbShort}
    * the remainder of the time (93%).
    */
-  public static final Gen<Short> arbShortBoundaries = sized(new F<Integer, Gen<Short>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Short> f(final Integer i) {
-      return frequency(list(p(1, value((short) 0)),
-                            p(1, value((short) 1)),
-                            p(1, value((short) -1)),
-                            p(1, value(Short.MAX_VALUE)),
-                            p(1, value(Short.MIN_VALUE)),
-                            p(1, value((short) (Short.MAX_VALUE - 1))),
-                            p(1, value((short) (Short.MIN_VALUE + 1))),
-                            p(93, arbShort)));
-    }
-  });
+  public static final Gen<Short> arbShortBoundaries = sized(i -> frequency(list(p(1, value((short) 0)),
+                        p(1, value((short) 1)),
+                        p(1, value((short) -1)),
+                        p(1, value(Short.MAX_VALUE)),
+                        p(1, value(Short.MIN_VALUE)),
+                        p(1, value((short) (Short.MAX_VALUE - 1))),
+                        p(1, value((short) (Short.MIN_VALUE + 1))),
+                        p(93, arbShort))));
 
   /**
    * An arbitrary implementation for character values.
@@ -486,16 +451,11 @@ public Gen<Short> f(final Integer i) {
    * max - 1, min + 1)</code> with a frequency of 1% each then generates from {@link #arbCharacter}
    * the remainder of the time (96%).
    */
-  public static final Gen<Character> arbCharacterBoundaries = sized(new F<Integer, Gen<Character>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Character> f(final Integer i) {
-      return frequency(list(p(1, value(Character.MIN_VALUE)),
-                            p(1, value((char) (Character.MIN_VALUE + 1))),
-                            p(1, value(Character.MAX_VALUE)),
-                            p(1, value((char) (Character.MAX_VALUE - 1))),
-                            p(95, arbCharacter)));
-    }
-  });
+  public static final Gen<Character> arbCharacterBoundaries = sized(i -> frequency(list(p(1, value(Character.MIN_VALUE)),
+                        p(1, value((char) (Character.MIN_VALUE + 1))),
+                        p(1, value(Character.MAX_VALUE)),
+                        p(1, value((char) (Character.MAX_VALUE - 1))),
+                        p(95, arbCharacter))));
 
   /**
    * An arbitrary implementation for double values.
@@ -507,21 +467,16 @@ public Gen<Character> f(final Integer i) {
    * min, min (normal), NaN, -infinity, infinity, max - 1)</code> with a frequency of 1% each then
    * generates from {@link #arbDouble} the remainder of the time (91%).
    */
-  public static final Gen<Double> arbDoubleBoundaries = sized(new F<Integer, Gen<Double>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Double> f(final Integer i) {
-      return frequency(list(p(1, value(0D)),
-                            p(1, value(1D)),
-                            p(1, value(-1D)),
-                            p(1, value(Double.MAX_VALUE)),
-                            p(1, value(Double.MIN_VALUE)),
-                            p(1, value(Double.NaN)),
-                            p(1, value(Double.NEGATIVE_INFINITY)),
-                            p(1, value(Double.POSITIVE_INFINITY)),
-                            p(1, value(Double.MAX_VALUE - 1D)),
-                            p(91, arbDouble)));
-    }
-  });
+  public static final Gen<Double> arbDoubleBoundaries = sized(i -> frequency(list(p(1, value(0D)),
+                        p(1, value(1D)),
+                        p(1, value(-1D)),
+                        p(1, value(Double.MAX_VALUE)),
+                        p(1, value(Double.MIN_VALUE)),
+                        p(1, value(Double.NaN)),
+                        p(1, value(Double.NEGATIVE_INFINITY)),
+                        p(1, value(Double.POSITIVE_INFINITY)),
+                        p(1, value(Double.MAX_VALUE - 1D)),
+                        p(91, arbDouble))));
 
   /**
    * An arbitrary implementation for float values.
@@ -533,21 +488,16 @@ public Gen<Double> f(final Integer i) {
    * min, NaN, -infinity, infinity, max - 1)</code> with a frequency of 1% each then generates from
    * {@link #arbFloat} the remainder of the time (91%).
    */
-  public static final Gen<Float> arbFloatBoundaries = sized(new F<Integer, Gen<Float>>() {
-    @SuppressWarnings("unchecked")
-    public Gen<Float> f(final Integer i) {
-      return frequency(list(p(1, value(0F)),
-                            p(1, value(1F)),
-                            p(1, value(-1F)),
-                            p(1, value(Float.MAX_VALUE)),
-                            p(1, value(Float.MIN_VALUE)),
-                            p(1, value(Float.NaN)),
-                            p(1, value(Float.NEGATIVE_INFINITY)),
-                            p(1, value(Float.POSITIVE_INFINITY)),
-                            p(1, value(Float.MAX_VALUE - 1F)),
-                            p(91, arbFloat)));
-    }
-  });
+  public static final Gen<Float> arbFloatBoundaries = sized(i -> frequency(list(p(1, value(0F)),
+                        p(1, value(1F)),
+                        p(1, value(-1F)),
+                        p(1, value(Float.MAX_VALUE)),
+                        p(1, value(Float.MIN_VALUE)),
+                        p(1, value(Float.NaN)),
+                        p(1, value(Float.NEGATIVE_INFINITY)),
+                        p(1, value(Float.POSITIVE_INFINITY)),
+                        p(1, value(Float.MAX_VALUE - 1F)),
+                        p(91, arbFloat))));
 
   /**
    * An arbitrary implementation for string values.
@@ -670,7 +620,7 @@ public static <A> Gen<NonEmptyList<A>> arbNonEmptyList(final Gen<A> aa) {
      * Returns an arbitrary Validation for the given arbitrary parameters.
      */
     public static <A, B> Gen<Validation<A, B>> arbValidation(final Gen<A> aa, final Gen<B> ab) {
-        return arbBoolean.bind(bool -> bool ? ab.map(Validation::<A, B>success) : aa.map(Validation::<A, B>fail));
+        return arbBoolean.bind(bool -> bool ? ab.map(Validation::success) : aa.map(Validation::fail));
     }
 
   /**
@@ -690,7 +640,7 @@ public static <A> Gen<Stream<A>> arbStream(final Gen<A> aa) {
    * @return An arbitrary implementation for arrays.
    */
   public static <A> Gen<Array<A>> arbArray(final Gen<A> aa) {
-    return arbList(aa).map(List<A>::toArray);
+    return arbList(aa).map(List::toArray);
   }
 
   /**
@@ -1029,8 +979,8 @@ public static <K, V> Gen<WeakHashMap<K, V>> arbWeakHashMap(final Gen<K> ak, fina
    */
   public static <A> Gen<ArrayBlockingQueue<A>> arbArrayBlockingQueue(final Gen<A> aa) {
     return arbArray(aa).bind(arbInteger, arbBoolean,
-        a -> capacity -> fair -> new ArrayBlockingQueue<A>(a.length() + abs(capacity),
-                                         fair, a.asJavaList()));
+        a -> capacity -> fair -> new ArrayBlockingQueue<>(a.length() + abs(capacity),
+            fair, a.asJavaList()));
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Arg.java b/quickcheck/src/main/java/fj/test/Arg.java
index 4187c15d..71df9e2d 100644
--- a/quickcheck/src/main/java/fj/test/Arg.java
+++ b/quickcheck/src/main/java/fj/test/Arg.java
@@ -1,6 +1,5 @@
 package fj.test;
 
-import fj.F;
 import fj.Show;
 
 import static fj.Show.anyShow;
@@ -52,10 +51,6 @@ public int shrinks() {
   /**
    * The rendering of an argument (uses {@link Object#toString()} for the argument value).
    */
-  public static final Show<Arg<?>> argShow = showS(new F<Arg<?>, String>() {
-    public String f(final Arg<?> arg) {
-      return anyShow().showS(arg.value) +
-          (arg.shrinks > 0 ? " (" + arg.shrinks + " shrink" + (arg.shrinks == 1 ? "" : 's') + ')' : "");
-    }
-  });
+  public static final Show<Arg<?>> argShow = showS(arg -> anyShow().showS(arg.value) +
+      (arg.shrinks > 0 ? " (" + arg.shrinks + " shrink" + (arg.shrinks == 1 ? "" : 's') + ')' : ""));
 }
diff --git a/quickcheck/src/main/java/fj/test/CheckResult.java b/quickcheck/src/main/java/fj/test/CheckResult.java
index c9c0a2fe..784fe4e9 100644
--- a/quickcheck/src/main/java/fj/test/CheckResult.java
+++ b/quickcheck/src/main/java/fj/test/CheckResult.java
@@ -286,16 +286,14 @@ else if (r.isPropException()) {
    *         the result is a failure (falsified, property exception or generator exception).
    */
   public static Show<CheckResult> summaryEx(final Show<Arg<?>> sa) {
-    return showS(new F<CheckResult, String>() {
-      public String f(final CheckResult r) {
-        final String s = summary(sa).showS(r);
-        if (r.isProven() || r.isPassed() || r.isExhausted())
-          return s;
-        else if (r.isFalsified() || r.isPropException() || r.isGenException())
-          throw new Error(s);
-        else
-          throw decons(r.getClass());
-      }
+    return showS(r -> {
+      final String s = summary(sa).showS(r);
+      if (r.isProven() || r.isPassed() || r.isExhausted())
+        return s;
+      else if (r.isFalsified() || r.isPropException() || r.isGenException())
+        throw new Error(s);
+      else
+        throw decons(r.getClass());
     });
   }
 }
diff --git a/quickcheck/src/main/java/fj/test/Cogen.java b/quickcheck/src/main/java/fj/test/Cogen.java
index c4c3b0a0..5770ea21 100644
--- a/quickcheck/src/main/java/fj/test/Cogen.java
+++ b/quickcheck/src/main/java/fj/test/Cogen.java
@@ -7,7 +7,6 @@
 
 import fj.data.*;
 
-import static fj.data.Array.array;
 import static fj.data.Array.iterableArray;
 import static fj.data.List.fromString;
 import static fj.data.List.nil;
@@ -501,11 +500,7 @@ public <B> Gen<B> cogen(final Array<A> as, final Gen<B> g) {
    * @return A cogen for throwables.
    */
   public static Cogen<Throwable> cogenThrowable(final Cogen<String> cs) {
-    return cs.contramap(new F<Throwable, String>() {
-      public String f(final Throwable t) {
-        return t.getMessage();
-      }
-    });
+    return cs.contramap(Throwable::getMessage);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 5b0a98bc..a5e30a9d 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -275,7 +275,7 @@ public <B, C, D, E> Gen<E> bind(final Gen<B> gb, final Gen<C> gc, final Gen<D> g
    * @return A new generator after function application.
    */
   public <B> Gen<B> apply(final Gen<F<A, B>> gf) {
-    return gf.bind(f1 -> map(f1));
+    return gf.bind(this::map);
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Property.java b/quickcheck/src/main/java/fj/test/Property.java
index 0f77f85e..2a327ebc 100644
--- a/quickcheck/src/main/java/fj/test/Property.java
+++ b/quickcheck/src/main/java/fj/test/Property.java
@@ -501,11 +501,7 @@ public static <A> Property property(final Gen<A> aa, final F<A, Property> f) {
    *         application of its arguments.
    */
   public static <A, B> Property propertyP(final Gen<A> aa, final Gen<B> ab, final Shrink<A> sa, final Shrink<B> sb, final F<A, F<B, P1<Property>>> f) {
-    return property(aa, sa, a -> {
-      return propertyP(ab, sb, b -> {
-        return f.f(a).f(b);
-      });
-    });
+    return property(aa, sa, a -> propertyP(ab, sb, b -> f.f(a).f(b)));
   }
 
   /**
@@ -633,9 +629,7 @@ public static <A, B, C> Property property(final Gen<A> aa,
                                             final Shrink<B> sb,
                                             final Shrink<C> sc,
                                             final F<A, F<B, F<C, Property>>> f) {
-    return property(aa, ab, sa, sb, a -> b -> property(ac, sc, c -> {
-      return f.f(a).f(b).f(c);
-    }));
+    return property(aa, ab, sa, sb, a -> b -> property(ac, sc, c -> f.f(a).f(b).f(c)));
   }
 
   /**
@@ -723,9 +717,7 @@ public static <A, B, C, D> Property property(final Gen<A> aa,
                                                final Shrink<C> sc,
                                                final Shrink<D> sd,
                                                final F<A, F<B, F<C, F<D, Property>>>> f) {
-    return property(aa, ab, ac, sa, sb, sc, a -> b -> c -> property(ad, sd, d -> {
-      return f.f(a).f(b).f(c).f(d);
-    }));
+    return property(aa, ab, ac, sa, sb, sc, a -> b -> c -> property(ad, sd, d -> f.f(a).f(b).f(c).f(d)));
   }
 
   /**
@@ -825,9 +817,7 @@ public static <A, B, C, D, E> Property property(final Gen<A> aa,
                                                   final Shrink<D> sd,
                                                   final Shrink<E> se,
                                                   final F<A, F<B, F<C, F<D, F<E, Property>>>>> f) {
-    return property(aa, ab, ac, ad, sa, sb, sc, sd, a -> b -> c -> d -> property(ae, se, e -> {
-      return f.f(a).f(b).f(c).f(d).f(e);
-    }));
+    return property(aa, ab, ac, ad, sa, sb, sc, sd, a -> b -> c -> d -> property(ae, se, e -> f.f(a).f(b).f(c).f(d).f(e)));
   }
 
   /**
@@ -939,9 +929,7 @@ public static <A, B, C, D, E> Property property(final Gen<A> aa,
                                                       final Shrink<E> se,
                                                       final Shrink<F$> sf,
                                                       final F<A, F<B, F<C, F<D, F<E, F<F$, Property>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, a -> b -> c -> d -> e -> property(af, sf, f$ -> {
-      return f.f(a).f(b).f(c).f(d).f(e).f(f$);
-    }));
+    return property(aa, ab, ac, ad, ae, sa, sb, sc, sd, se, a -> b -> c -> d -> e -> property(af, sf, f$ -> f.f(a).f(b).f(c).f(d).f(e).f(f$)));
   }
 
   /**
@@ -1065,9 +1053,7 @@ public static <A, B, C, D, E> Property property(final Gen<A> aa,
                                                          final Shrink<F$> sf,
                                                          final Shrink<G> sg,
                                                          final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, Property>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, a -> b -> c -> d -> e -> f$ -> property(ag, sg, g -> {
-      return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g);
-    }));
+    return property(aa, ab, ac, ad, ae, af, sa, sb, sc, sd, se, sf, a -> b -> c -> d -> e -> f$ -> property(ag, sg, g -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g)));
   }
 
   /**
@@ -1203,9 +1189,7 @@ public static <A, B, C, D, E> Property property(final Gen<A> aa,
                                                             final Shrink<G> sg,
                                                             final Shrink<H> sh,
                                                             final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, Property>>>>>>>> f) {
-    return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, a -> b -> c -> d -> e -> f$ -> g -> property(ah, sh, h -> {
-      return f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h);
-    }));
+    return property(aa, ab, ac, ad, ae, af, ag, sa, sb, sc, sd, se, sf, sg, a -> b -> c -> d -> e -> f$ -> g -> property(ah, sh, h -> f.f(a).f(b).f(c).f(d).f(e).f(f$).f(g).f(h)));
   }
 
   /**
diff --git a/quickcheck/src/main/java/fj/test/Shrink.java b/quickcheck/src/main/java/fj/test/Shrink.java
index 77c95381..483293e8 100644
--- a/quickcheck/src/main/java/fj/test/Shrink.java
+++ b/quickcheck/src/main/java/fj/test/Shrink.java
@@ -23,7 +23,7 @@
 import static fj.Primitive.Long_Integer;
 import static fj.Primitive.Long_Short;
 import static fj.Primitive.Short_Long;
-import static fj.data.Array.array;
+
 import fj.data.Conversions;
 import static fj.data.List.isNotEmpty_;
 import fj.data.Array;
@@ -38,7 +38,6 @@
 import static fj.data.Stream.iterate;
 import static fj.data.Stream.nil;
 
-import static java.lang.System.arraycopy;
 import static java.math.BigInteger.ZERO;
 
 import java.math.BigDecimal;
@@ -683,7 +682,7 @@ public static <A> Shrink<SynchronousQueue<A>> shrinkSynchronousQueue(final Shrin
       final Stream<BigInteger> is = cons(ZERO,
               () -> iterate(x -> x.divide(two), i)
                       .takeWhile(x2 -> eq.notEq(x2, ZERO))
-                      .map(i::subtract));
+                      .map(x2 -> i.subtract(x2)));
 
       return Ord.bigintOrd.isLessThan(i, ZERO) ? cons(i.negate(), () -> is) : is;
     }
diff --git a/quickcheck/src/main/java/fj/test/reflect/Check.java b/quickcheck/src/main/java/fj/test/reflect/Check.java
index eb865e04..a1eea79b 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Check.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Check.java
@@ -1,6 +1,5 @@
 package fj.test.reflect;
 
-import fj.Class;
 import static fj.Class.clas;
 import fj.F;
 import fj.Function;
@@ -24,8 +23,7 @@
 
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
+
 import static java.lang.reflect.Modifier.isStatic;
 
 /**
@@ -177,7 +175,7 @@ public static <T> List<P2<String, CheckResult>> check(final java.lang.Class<T> c
    */
   public static <U, T extends U> List<P3<Property, String, Option<CheckParams>>> properties(final java.lang.Class<T> c, final String... categories) {
     //noinspection ClassEscapesDefinedScope
-    final Array<P3<Property, String, Option<CheckParams>>> propFields = properties(array(c.getDeclaredFields()).map((F<Field, PropertyMember>) f -> new PropertyMember() {
+    final Array<P3<Property, String, Option<CheckParams>>> propFields = properties(array(c.getDeclaredFields()).map(f -> new PropertyMember() {
       public java.lang.Class<?> type() {
         return f.getType();
       }
@@ -205,7 +203,7 @@ public boolean isProperty() {
     }), c, categories);
 
     //noinspection ClassEscapesDefinedScope
-    final Array<P3<Property, String, Option<CheckParams>>> propMethods = properties(array(c.getDeclaredMethods()).map((F<Method, PropertyMember>) m -> {
+    final Array<P3<Property, String, Option<CheckParams>>> propMethods = properties(array(c.getDeclaredMethods()).map(m -> {
       //noinspection ProhibitedExceptionDeclared
       return new PropertyMember() {
         public java.lang.Class<?> type() {
diff --git a/quickcheck/src/main/java/fj/test/reflect/CheckParams.java b/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
index 8c8445c1..7951b40e 100644
--- a/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
+++ b/quickcheck/src/main/java/fj/test/reflect/CheckParams.java
@@ -1,5 +1,6 @@
 package fj.test.reflect;
 
+import fj.F0;
 import fj.test.Property;
 
 import java.lang.annotation.Documented;
diff --git a/quickcheck/src/main/java/fj/test/reflect/Main.java b/quickcheck/src/main/java/fj/test/reflect/Main.java
index 5f6f3dfc..b07997c2 100644
--- a/quickcheck/src/main/java/fj/test/reflect/Main.java
+++ b/quickcheck/src/main/java/fj/test/reflect/Main.java
@@ -1,10 +1,7 @@
 package fj.test.reflect;
 
-import fj.P2;
 import static fj.data.Array.array;
 
-import fj.function.Effect1;
-import fj.test.CheckResult;
 import static fj.test.CheckResult.summary;
 import static fj.test.reflect.Check.check;
 
diff --git a/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java b/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
index 876dbff1..8b90d57c 100644
--- a/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
+++ b/quickcheck/src/main/java/fj/test/runner/PropertyTestRunner.java
@@ -58,11 +58,10 @@ private static String getLabel(Description d) {
     }
 
   private static CheckResult checkProperty(Property prop, Option<CheckParams> params) {
-    for (CheckParams ps : params) {
-      return prop.check(ps.minSuccessful(), ps.maxDiscarded(), ps.minSize(), ps.maxSize());
-    }
-
-    return prop.check();
+    return params.<CheckResult>option(
+        prop::check,
+        ps -> prop.check(ps.minSuccessful(), ps.maxDiscarded(), ps.minSize(), ps.maxSize())
+    );
   }
 
   @Override
diff --git a/quickcheck/src/test/java/fj/data/test/TestCheck.java b/quickcheck/src/test/java/fj/data/test/TestCheck.java
index 935f1127..3a4e6a80 100644
--- a/quickcheck/src/test/java/fj/data/test/TestCheck.java
+++ b/quickcheck/src/test/java/fj/data/test/TestCheck.java
@@ -1,16 +1,10 @@
 package fj.data.test;
 
-import fj.F2;
-import fj.F3;
-import fj.data.List;
-import fj.test.Arbitrary;
 import fj.test.CheckResult;
 import fj.test.Gen;
 import fj.test.Property;
 import org.junit.*;
 
-import static fj.Function.compose;
-import static fj.test.Arbitrary.arbLong;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.junit.Assert.*;
@@ -19,13 +13,11 @@ public class TestCheck {
 
 	@Test(timeout=5000 /*ms*/)
 	public void testExceptionsThrownFromGeneratorsArePropagated() {
-		Gen<Integer> failingGen = Gen.<Integer>value(0).map((i) -> {
+		Gen<Integer> failingGen = Gen.value(0).map((i) -> {
 			throw new RuntimeException("test failure");
 		});
 
-		Property p = property(failingGen, (Integer i) -> {
-			return prop(i == 0);
-		});
+		Property p = property(failingGen, (Integer i) -> prop(i == 0));
 
 		CheckResult res = p.check(
 			1, /*minSuccessful*/
diff --git a/quickcheck/src/test/java/fj/data/test/TestNull.java b/quickcheck/src/test/java/fj/data/test/TestNull.java
index 0fd44c6a..fe9dc843 100644
--- a/quickcheck/src/test/java/fj/data/test/TestNull.java
+++ b/quickcheck/src/test/java/fj/data/test/TestNull.java
@@ -1,16 +1,10 @@
 package fj.data.test;
 
-import fj.F2;
-import fj.F3;
-import fj.data.List;
-import fj.test.Arbitrary;
 import fj.test.CheckResult;
 import fj.test.Gen;
 import fj.test.Property;
 import org.junit.Test;
 
-import static fj.Function.compose;
-import static fj.test.Arbitrary.arbLong;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
@@ -21,9 +15,7 @@ public class TestNull {
 
 	@Test
 	public void testShowNullParameters() {
-		Property p = property(Gen.<Integer>value(null), (Integer i) -> {
-				return prop(i != null);
-		});
+		Property p = property(Gen.value(null), (Integer i) -> prop(i != null));
 		CheckResult.summary.println(p.check());
 	}
 
diff --git a/quickcheck/src/test/java/fj/test/GenTest.java b/quickcheck/src/test/java/fj/test/GenTest.java
index 3bb723b8..900369a7 100644
--- a/quickcheck/src/test/java/fj/test/GenTest.java
+++ b/quickcheck/src/test/java/fj/test/GenTest.java
@@ -22,9 +22,7 @@ public final class GenTest {
   @Test
   public void testCombinationOf_none() {
     Gen<List<Character>> instance = combinationOf(0, AS);
-    testPick(100, instance, actual -> {
-      assertTrue(actual.isEmpty());
-    });
+    testPick(100, instance, actual -> assertTrue(actual.isEmpty()));
   }
 
   @Test
@@ -59,9 +57,7 @@ public void testCombinationOf_three() {
   @Test
   public void testSelectionOf_none() {
     Gen<List<Character>> instance = selectionOf(0, AS);
-    testPick(100, instance, actual -> {
-      assertTrue(actual.isEmpty());
-    });
+    testPick(100, instance, actual -> assertTrue(actual.isEmpty()));
   }
 
   @Test
@@ -106,9 +102,7 @@ public void testSelectionOf_four() {
   @Test
   public void testPermutationOf_none() {
     Gen<List<Character>> instance = permutationOf(0, AS);
-    testPick(100, instance, actual -> {
-      assertTrue(actual.isEmpty());
-    });
+    testPick(100, instance, actual -> assertTrue(actual.isEmpty()));
   }
 
   @Test
@@ -142,9 +136,7 @@ public void testPermutationOf_three() {
   @Test
   public void testWordOf_none() {
     Gen<List<Character>> instance = wordOf(0, AS);
-    testPick(100, instance, actual -> {
-      assertTrue(actual.isEmpty());
-    });
+    testPick(100, instance, actual -> assertTrue(actual.isEmpty()));
   }
 
   @Test
@@ -184,7 +176,7 @@ public void testWordOf_four() {
   }
 
   private static <A> void testPick(int n, Gen<List<A>> instance, Effect1<List<A>> test) {
-    range(0, n).map(ignore -> instance.gen(0, standard)).foreachDoEffect(test::f);
+    range(0, n).map(ignore -> instance.gen(0, standard)).foreachDoEffect(test);
   }
 
 }

From 5b6b88979c717c03d47d9d3977912df9b7f72153 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sat, 25 Aug 2018 21:16:44 +0200
Subject: [PATCH 215/336] Initiate 5.x series: build with jdk11 by default.

 Move java8 to core.
---
 .travis.yml                                   | 11 +++--
 build.gradle                                  | 22 ++++-----
 core/build.gradle                             |  2 -
 .../src/main/java/fj/data/Collectors.java     |  0
 .../src/main/java/fj/data/Java8.java          | 22 ++++-----
 demo/build.gradle                             |  2 -
 java-core/build.gradle                        |  2 -
 java8/build.gradle                            | 18 -------
 java8/src/test/java/fj/EmptyTest.java         | 17 -------
 lib.gradle                                    | 24 ----------
 performance/build.gradle                      |  2 -
 props-core/build.gradle                       |  2 -
 quickcheck/build.gradle                       |  2 -
 .../src/main/java/fj/test/Arbitrary.java      | 48 +++++++++----------
 settings.gradle                               |  2 +-
 15 files changed, 52 insertions(+), 124 deletions(-)
 rename {java8 => core}/src/main/java/fj/data/Collectors.java (100%)
 rename {java8 => core}/src/main/java/fj/data/Java8.java (97%)
 delete mode 100644 java8/build.gradle
 delete mode 100644 java8/src/test/java/fj/EmptyTest.java

diff --git a/.travis.yml b/.travis.yml
index 7c55b120..bbe5966b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,19 +4,24 @@ sudo: false
 language: java
 
 jdk:
- - openjdk11
+ - openjdk10
+ - openjdk-ea
 
 matrix:
 
   include:
-  - jdk: openjdk8
+  - jdk: openjdk11
     script:
       - ./gradlew build coverage -s -i
     after_success:
       - bash <(curl -s https://codecov.io/bash)
-      - '[ "$TRAVIS_BRANCH" = "series/4.x" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
+      - '[ "$TRAVIS_BRANCH" = "series/5.x" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
         && ./gradlew uploadArchives'
 
+  allow_failures:
+  - jdk: openjdk10
+  - jdk: openjdk-ea
+
 script:
   - ./gradlew clean test
 
diff --git a/build.gradle b/build.gradle
index 9d98d2b3..b386b5d3 100644
--- a/build.gradle
+++ b/build.gradle
@@ -7,8 +7,6 @@ ext {
 buildscript {
     ext {
         uptodateVersion = "1.6.3"
-        retrolambdaPluginVersion = "3.7.0"
-        retrolambdaVersion = "2.5.4"
     }
 
     repositories {
@@ -19,7 +17,6 @@ buildscript {
 
     dependencies {
         classpath "com.ofg:uptodate-gradle-plugin:$uptodateVersion"
-        classpath "me.tatarka:gradle-retrolambda:$retrolambdaPluginVersion"
     }
 }
 
@@ -43,14 +40,13 @@ allprojects {
 
     ext {
         isSnapshot = true
-        fjBaseVersion = "4.9"
+        fjBaseVersion = "5.0"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
         fjConsumeVersion = "4.8"
 
         signModule = false
-        useRetroLambda = false
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
@@ -71,10 +67,6 @@ allprojects {
         dependencyJunit = "org.junit.vintage:junit-vintage-engine:5.2.0"
 
         displayCompilerWarnings = true
-
-        newJdkEnvVar = "JAVA8_HOME"
-        oldJdkEnvVar = "JAVA7_HOME"
-        retroLambdaTarget = JavaVersion.VERSION_1_6
     }
 
     repositories {
@@ -111,11 +103,13 @@ subprojects {
 		}
 	}
 
-	if (displayCompilerWarnings) {
-		tasks.withType(JavaCompile) {
+
+	tasks.withType(JavaCompile) {
+        options.compilerArgs.addAll(['--release', '10'])
+        if (displayCompilerWarnings) {
 			options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
-		}
-	}
+       }
+    }
 
     jacocoTestReport {
         additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
@@ -136,7 +130,7 @@ task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
     dependsOn = subprojects.coverage
     executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")
     // We only care about coverage of:
-    def projectForFoverage = ["core", "java8", "quickcheck", "java-core"]
+    def projectForFoverage = ["core", "quickcheck", "java-core"]
     classDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.output)
     sourceDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.allSource.srcDirs)
 
diff --git a/core/build.gradle b/core/build.gradle
index 71dae913..13d06114 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -15,5 +15,3 @@ performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)
 
 uploadArchives.enabled = true
-
-configureAllRetroLambda()
diff --git a/java8/src/main/java/fj/data/Collectors.java b/core/src/main/java/fj/data/Collectors.java
similarity index 100%
rename from java8/src/main/java/fj/data/Collectors.java
rename to core/src/main/java/fj/data/Collectors.java
diff --git a/java8/src/main/java/fj/data/Java8.java b/core/src/main/java/fj/data/Java8.java
similarity index 97%
rename from java8/src/main/java/fj/data/Java8.java
rename to core/src/main/java/fj/data/Java8.java
index e41f0958..46c5ca2a 100644
--- a/java8/src/main/java/fj/data/Java8.java
+++ b/core/src/main/java/fj/data/Java8.java
@@ -1,14 +1,5 @@
 package fj.data;
 
-import java.util.Iterator;
-import java.util.Optional;
-import java.util.Spliterators;
-import java.util.function.BiFunction;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-import java.util.stream.StreamSupport;
-
 import fj.F;
 import fj.F2;
 import fj.P;
@@ -19,6 +10,15 @@
 import fj.function.Try1;
 import fj.function.Try2;
 
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.Spliterators;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.StreamSupport;
+
 /**
  * Created by mperry on 3/06/2014.
  */
@@ -134,7 +134,7 @@ public static <A> F<A, Unit> Consumer_F(final Consumer<A> c) {
         };
     }
 
-    public static <A> java.util.stream.Stream<A> Stream_JavaStream(final fj.data.Stream<A> s) {
+    public static <A> java.util.stream.Stream<A> Stream_JavaStream(final Stream<A> s) {
         return Iterable_JavaStream(s);
     }
 
@@ -146,7 +146,7 @@ public static <A> java.util.stream.Stream<A> Iterator_JavaStream(final Iterator<
         return StreamSupport.stream(Spliterators.spliteratorUnknownSize(it, 0), false);
     }
 
-    public static <A> F<fj.data.Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
+    public static <A> F<Stream<A>, java.util.stream.Stream<A>> Stream_JavaStream() {
         return Java8::Stream_JavaStream;
     }
 
diff --git a/demo/build.gradle b/demo/build.gradle
index b79cb246..e97f94b8 100644
--- a/demo/build.gradle
+++ b/demo/build.gradle
@@ -5,8 +5,6 @@ mainClassName = "fj.demo.euler.Problem2"
 
 archivesBaseName = "${project.projectName}-${project.name}"
 
-configureAllRetroLambda()
-
 dependencies {
     compile project(":core")
     compile project(":quickcheck")
diff --git a/java-core/build.gradle b/java-core/build.gradle
index b5ee71ec..22bf8970 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -15,5 +15,3 @@ configureUpload(signingEnabled, signModule)
 
 
 uploadArchives.enabled = true
-
-configureAllRetroLambda()
diff --git a/java8/build.gradle b/java8/build.gradle
deleted file mode 100644
index d6d4c485..00000000
--- a/java8/build.gradle
+++ /dev/null
@@ -1,18 +0,0 @@
-
-archivesBaseName = "${project.projectName}-${project.name}"
-
-ext {
-    signModule = true
-}
-
-dependencies {
-    compile project(":core")
-    testCompile dependencyJunit
-}
-
-performSigning(signingEnabled, signModule)
-configureUpload(signingEnabled, signModule)
-
-if (!useRetroLambda) {
-    uploadArchives.enabled = true
-}
diff --git a/java8/src/test/java/fj/EmptyTest.java b/java8/src/test/java/fj/EmptyTest.java
deleted file mode 100644
index e187cccb..00000000
--- a/java8/src/test/java/fj/EmptyTest.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package fj;
-
-import org.junit.Assert;
-import org.junit.Ignore;
-import org.junit.Test;
-
-/**
- * Created by MarkPerry on 30/08/2015.
- */
-public class EmptyTest {
-
-    @Ignore @Test
-    public void missing() {
-        Assert.fail("not implemented");
-
-    }
-}
diff --git a/lib.gradle b/lib.gradle
index 253ed251..39ce7a7e 100644
--- a/lib.gradle
+++ b/lib.gradle
@@ -77,33 +77,9 @@ void configureUpload(String signingEnabled, Boolean signModule) {
     }
 }
 
-void configureAllRetroLambda() {
-    configureRetroLambda(useRetroLambda, newJdkEnvVar, oldJdkEnvVar, retroLambdaTarget)
-}
-
-void configureRetroLambda(boolean useRetroLambda, String newJdkEnvVar, String oldJdkEnvVar, JavaVersion retroLambdaTarget) {
-
-    if (useRetroLambda) {
-        apply plugin: 'me.tatarka.retrolambda'
-        retrolambda {
-            jdk System.getenv(newJdkEnvVar)
-            oldJdk System.getenv(oldJdkEnvVar)
-            javaVersion retroLambdaTarget
-            defaultMethods true
-        }
-        dependencies {
-            retrolambdaConfig "net.orfjackal.retrolambda:retrolambda:$retrolambdaVersion"
-        }
-    } else {
-        project.archivesBaseName = "${project.archivesBaseName}_1.8"
-    }
-}
-
 ext {
     findJavaCommand = this.&findJavaCommand
     doSigning = this.&doSigning
     performSigning = this.&performSigning
     configureUpload = this.&configureUpload
-    configureRetroLambda = this.&configureRetroLambda
-    configureAllRetroLambda = this.&configureAllRetroLambda
 }
diff --git a/performance/build.gradle b/performance/build.gradle
index b5bc2916..cac2f584 100644
--- a/performance/build.gradle
+++ b/performance/build.gradle
@@ -1,6 +1,4 @@
 
-configureAllRetroLambda()
-
 dependencies {
     compile project(":core")
     testCompile dependencyJunit
diff --git a/props-core/build.gradle b/props-core/build.gradle
index d697cff5..181ae5b2 100644
--- a/props-core/build.gradle
+++ b/props-core/build.gradle
@@ -1,8 +1,6 @@
 
 archivesBaseName = "${project.projectName}-${project.name}"
 
-configureAllRetroLambda()
-
 dependencies {
 	compile project(":quickcheck")
     testCompile dependencyJunit
diff --git a/quickcheck/build.gradle b/quickcheck/build.gradle
index 45e379da..b477e26a 100644
--- a/quickcheck/build.gradle
+++ b/quickcheck/build.gradle
@@ -5,8 +5,6 @@ ext {
 
 archivesBaseName = "${project.projectName}-${project.name}"
 
-configureAllRetroLambda()
-
 dependencies {
 	compile project(":core")
     compile dependencyJunit
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 95bdedca..8e5461fd 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -260,13 +260,13 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
    * @return An arbitrary for function-6.
    */
   public static <A, B, C, D, E, F$, G> Gen<F6<A, B, C, D, E, F$, G>> arbF6Invariant(final Gen<G> a) {
-    return a.map(compose(Function.<A, B, C, D, E, F$, G>uncurryF6(),
-        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>>constant(),
-            compose(Function.<B, F<C, F<D, F<E, F<F$, G>>>>>constant(),
-                compose(Function.<C, F<D, F<E, F<F$, G>>>>constant(),
-                    compose(Function.<D, F<E, F<F$, G>>>constant(),
-                        compose(Function.<E, F<F$, G>>constant(),
-                            Function.<F$, G>constant())))))));
+    return a.map(compose(Function.uncurryF6(),
+        compose(Function.constant(),
+            compose(Function.constant(),
+                compose(Function.constant(),
+                    compose(Function.constant(),
+                        compose(Function.constant(),
+                            Function.constant())))))));
   }
 
   /**
@@ -301,14 +301,14 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
    * @return An arbitrary for function-7.
    */
   public static <A, B, C, D, E, F$, G, H> Gen<F7<A, B, C, D, E, F$, G, H>> arbF7Invariant(final Gen<H> a) {
-    return a.map(compose(Function.<A, B, C, D, E, F$, G, H>uncurryF7(),
-        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>>constant(),
-            compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>constant(),
-                compose(Function.<C, F<D, F<E, F<F$, F<G, H>>>>>constant(),
-                    compose(Function.<D, F<E, F<F$, F<G, H>>>>constant(),
-                        compose(Function.<E, F<F$, F<G, H>>>constant(),
-                            compose(Function.<F$, F<G, H>>constant(),
-                                Function.<G, H>constant()))))))));
+    return a.map(compose(Function.uncurryF7(),
+        compose(Function.constant(),
+            compose(Function.constant(),
+                compose(Function.constant(),
+                    compose(Function.constant(),
+                        compose(Function.constant(),
+                            compose(Function.constant(),
+                                Function.constant()))))))));
   }
 
   /**
@@ -346,17 +346,17 @@ public static <A, B, C, D, E> Gen<F4<A, B, C, D, E>> arbF4Invariant(final Gen<E>
    */
   public static <A, B, C, D, E, F$, G, H, I> Gen<F8<A, B, C, D, E, F$, G, H, I>> arbF8Invariant(
       final Gen<I> a) {
-    return a.map(compose(Function.<A, B, C, D, E, F$, G, H, I>uncurryF8(),
-        compose(Function.<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>>constant(),
-            compose(Function.<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>constant(),
-                compose(Function.<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>constant(),
+    return a.map(compose(Function.uncurryF8(),
+        compose(Function.constant(),
+            compose(Function.constant(),
+                compose(Function.constant(),
                     compose(
-                        Function.<D, F<E, F<F$, F<G, F<H, I>>>>>constant(),
-                        compose(Function.<E, F<F$, F<G, F<H, I>>>>constant(),
+                        Function.constant(),
+                        compose(Function.constant(),
                             compose(
-                                Function.<F$, F<G, F<H, I>>>constant(),
-                                compose(Function.<G, F<H, I>>constant(),
-                                    Function.<H, I>constant())))))))));
+                                Function.constant(),
+                                compose(Function.constant(),
+                                    Function.constant())))))))));
   }
 
   /**
diff --git a/settings.gradle b/settings.gradle
index d231d998..f1a6bd56 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,5 +1,5 @@
 
 rootProject.name = "functionaljava"
 
-include "core", "demo", "consume", "java8", "quickcheck", "props-core", "props-core-scalacheck", "java-core", "performance"
+include "core", "demo", "consume", "quickcheck", "props-core", "props-core-scalacheck", "java-core", "performance"
 

From 2e1f2c57176a2bf8974ef0725e681e9042cff9ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 23 Sep 2018 14:28:40 -0400
Subject: [PATCH 216/336] Add Strategy tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 .../fj/control/parallel/StrategyTest.java     | 61 +++++++++++++++++++
 core/src/test/java/fj/data/StreamTest.java    | 16 -----
 2 files changed, 61 insertions(+), 16 deletions(-)
 create mode 100644 core/src/test/java/fj/control/parallel/StrategyTest.java

diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
new file mode 100644
index 00000000..ee3b30df
--- /dev/null
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -0,0 +1,61 @@
+package fj.control.parallel;
+
+import fj.Ord;
+import fj.P;
+import fj.P1;
+import fj.data.Enumerator;
+import fj.data.List;
+import fj.data.Stream;
+import org.junit.Test;
+
+import java.util.concurrent.*;
+
+import static fj.control.parallel.Callables.callable;
+import static fj.control.parallel.Strategy.*;
+import static fj.data.Stream.range;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class StrategyTest {
+
+    @Test
+    public void testStrategySeq() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, seqStrategy()), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyThread() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, simpleThreadStrategy()), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyExecutor() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        final ExecutorService es = Executors.newFixedThreadPool(10);
+        assertThat(s.sort(Ord.intOrd, executorStrategy(es)), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyCompletion() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        final ExecutorService es = Executors.newFixedThreadPool(10);
+        final CompletionService cs = new ExecutorCompletionService(es);
+        assertThat(s.sort(Ord.intOrd, completionStrategy(cs)), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyMergeAll() {
+        final List<Integer> l = List.range(0, 100);
+        final List<P1<Integer>> p1s = mergeAll(l.map(x -> CompletableFuture.supplyAsync(() -> x)));
+        assertThat(P1.sequence(p1s)._1(), is(l));
+    }
+
+    @Test
+    public void testStrategyCallables() throws Exception {
+        final Strategy<Callable<Integer>> s = strategy(c -> c);
+        final Strategy<Callable<Integer>> cs = callableStrategy(s);
+        assertThat(callableStrategy(s).par(P.p(callable(1)))._1().call(), is(1));
+    }
+}
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index b65e115c..999a3a3e 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -1,9 +1,7 @@
 package fj.data;
 
 import fj.Equal;
-import fj.Ord;
 import fj.P2;
-import fj.control.parallel.Strategy;
 import org.junit.Test;
 
 import java.util.ConcurrentModificationException;
@@ -105,18 +103,4 @@ public void testMinus() {
         assertThat(s1.minus(Equal.charEqual, s2),
                 is(stream(new Character[]{'a', 'c', 'd'})));
     }
-
-    @Test
-    public void testSortSeq() {
-        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
-        assertThat(s.sort(Ord.intOrd, Strategy.seqStrategy()),
-                is(s.sort(Ord.intOrd)));
-    }
-
-    @Test
-    public void testSortThread() {
-        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
-        assertThat(s.sort(Ord.intOrd, Strategy.simpleThreadStrategy()),
-                is(s.sort(Ord.intOrd)));
-    }
 }

From 9893314de654075a46f53f6aa6edb4e0426228bd Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 7 Oct 2018 11:13:26 +0200
Subject: [PATCH 217/336] Fix regression in lifted semigroup sum. Move lifted
 definition in Monoid.

---
 core/src/main/java/fj/Monoid.java     | 31 +++++++++++++++++++++++++++
 core/src/main/java/fj/Semigroup.java  | 24 +--------------------
 core/src/test/java/fj/MonoidTest.java | 19 ++++++++++++++++
 3 files changed, 51 insertions(+), 23 deletions(-)
 create mode 100644 core/src/test/java/fj/MonoidTest.java

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 3fcf1775..cdb8e746 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -17,6 +17,7 @@
 import static fj.data.List.nil;
 import static fj.data.Natural.natural;
 import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static fj.data.Stream.iterableStream;
 
 import java.math.BigInteger;
@@ -867,6 +868,36 @@ public List<A> sum(F0<Stream<List<A>>> as) {
     });
   }
 
+  /**
+   * Lift a {@code Semigroup<A>} for A to a {@code Monoid<Option<A>>}, using Option.none() as zero.
+   *
+   * @return A monoid for option.
+   */
+  public static <A> Monoid<Option<A>> optionMonoid(Semigroup<A> aSemigroup) {
+    return monoidDef(new Monoid.Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a1.liftM2(a2, aSemigroup::sum).orElse(a1).orElse(a2);
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> oa) {
+        return n > 0 ? oa.map(a -> aSemigroup.multiply1p(n - 1, a)) : none();
+      }
+
+      @Override
+      public Option<A> sum(F0<Stream<Option<A>>> oas) {
+        Stream<A> as = oas.f().bind(Option::toStream);
+        return as.uncons(none(), h -> tail ->  some(aSemigroup.sumStream(h, tail::_1)));
+      }
+    });
+  }
+
   /**
    * A monoid for options.
    * @deprecated since 4.7. Use {@link #firstOptionMonoid()}.
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 16b0d130..f626ded7 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -172,29 +172,7 @@ public Semigroup<A> dual() {
    * Lifts the semigroup to obtain a trivial monoid.
    */
   public Monoid<Option<A>> lift() {
-    Definition<A> def = this.def;
-    return monoidDef(new Monoid.Definition<Option<A>>() {
-      @Override
-      public Option<A> empty() {
-        return none();
-      }
-
-      @Override
-      public Option<A> append(Option<A> a1, Option<A> a2) {
-        return a1.liftM2(a1, def::append).orElse(a1).orElse(a2);
-      }
-
-      @Override
-      public Option<A> multiply(int n, Option<A> oa) {
-        return n > 0 ? oa.map(a -> def.multiply1p(n - 1, a)) : none();
-      }
-
-      @Override
-      public Option<A> sum(F0<Stream<Option<A>>> oas) {
-        Stream<A> as = oas.f().bind(Option::toStream);
-        return as.uncons(none(), h -> tail ->  some(def.sum(h, tail::_1)));
-      }
-    });
+    return Monoid.optionMonoid(this);
   }
 
   /**
diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
new file mode 100644
index 00000000..8bab5315
--- /dev/null
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -0,0 +1,19 @@
+package fj;
+
+import fj.data.Option;
+import fj.data.Stream;
+import org.junit.Test;
+
+import static fj.data.Option.some;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class MonoidTest {
+
+  @Test
+  public void lifted_sum_of_two_numbers() {
+    Monoid<Option<Integer>> optionMonoid = Semigroup.intAdditionSemigroup.lift();
+    assertThat(optionMonoid.sum(some(3), some(5)), is(some(8)));
+    assertThat(optionMonoid.sumLeft(Stream.arrayStream(some(3), some(5))), is(some(8)));
+  }
+}

From d3d876c28b31b5ad210302614abdd2e8c7b3165f Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 7 Oct 2018 11:25:47 +0200
Subject: [PATCH 218/336] Add Trampoline.suspend(final F0<Trampoline<A>> a).

---
 core/src/main/java/fj/control/Trampoline.java | 17 ++++++++++++++---
 core/src/main/java/fj/data/DList.java         |  2 +-
 core/src/main/java/fj/data/Eval.java          |  6 +++---
 core/src/main/java/fj/data/List.java          |  2 +-
 core/src/main/java/fj/data/State.java         |  3 +--
 quickcheck/src/main/java/fj/test/Gen.java     |  5 ++---
 6 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 37491c3b..0b6060b1 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -46,7 +46,7 @@ public <R> R fold(final F<Normal<A>, R> n,
     // The monadic bind constructs a new Codense whose subcomputation is still `sub`, and Kleisli-composes the
     // continuations.
     public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
-      return codense(sub, o -> suspend(P.lazy(() -> cont.f(o).bind(f))));
+      return codense(sub, o -> suspend(() -> cont.f(o).bind(f)));
     }
 
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
@@ -126,6 +126,16 @@ public static <A> Trampoline<A> pure(final A a) {
     return new Pure<>(a);
   }
 
+  /**
+   * Suspends the given computation in a thunk.
+   *
+   * @param a A trampoline suspended in a thunk.
+   * @return A trampoline whose next step runs the given thunk.
+   */
+  public static <A> Trampoline<A> suspend(final F0<Trampoline<A>> a) {
+    return new Suspend<>(P.lazy(a));
+  }
+
   /**
    * Suspends the given computation in a thunk.
    *
@@ -136,6 +146,7 @@ public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
     return new Suspend<>(a);
   }
 
+
   /**
    * @return The first-class version of `suspend`.
    */
@@ -255,7 +266,7 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(P.lazy(() -> ta.zipWith(tb, f))))));
+        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(() -> ta.zipWith(tb, f)))));
       }
       for (final B y : eb.right()) {
         return suspend(x.map(ta -> ta.map(F2Functions.f(F2Functions.flip(f), y))));
@@ -263,7 +274,7 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     }
     for (final A x : ea.right()) {
       for (final B y : eb.right()) {
-        return suspend(P.lazy(() -> pure(f.f(x, y))));
+        return suspend(() -> pure(f.f(x, y)));
       }
       for (final P1<Trampoline<B>> y : eb.left()) {
         return suspend(y.map(liftM2(F2Functions.curry(f)).f(pure(x))));
diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index af9d68b0..597b6dda 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -126,6 +126,6 @@ public DList<A> append(DList<A> other) {
     }
     
     private static <A,B,C> F<A,Trampoline<C>> kleisliTrampCompose(F<B,Trampoline<C>> bc, F<A,Trampoline<B>> ab) {
-        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(P.lazy(() -> bc.f(b))));
+        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(() -> bc.f(b)));
     }
 }
diff --git a/core/src/main/java/fj/data/Eval.java b/core/src/main/java/fj/data/Eval.java
index 3e513075..5d09f913 100644
--- a/core/src/main/java/fj/data/Eval.java
+++ b/core/src/main/java/fj/data/Eval.java
@@ -204,7 +204,7 @@ private static final class PureTrampolineEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> Trampoline.pure(start.value())));
+      return Trampoline.suspend(() -> Trampoline.pure(start.value()));
     }
   }
 
@@ -219,7 +219,7 @@ private static final class BindTrampolineEval<A, B> extends TrampolineEval<B> {
 
     @Override
     protected final Trampoline<B> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline())));
+      return Trampoline.suspend(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline()));
     }
   }
 
@@ -232,7 +232,7 @@ private static final class DeferEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> memo._1().asTrampoline().trampoline()));
+      return Trampoline.suspend(() -> memo._1().asTrampoline().trampoline());
     }
   }
 }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index f58fd73f..e0e12877 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -736,7 +736,7 @@ public final <B> B foldRight(final F2<A, B, B> f, final B b) {
    * @return A Trampoline containing the final result after the right-fold reduction.
    */
   public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
-    return Trampoline.suspend(P.lazy(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head()))));
+    return Trampoline.suspend(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head())));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 1b30a55e..f29d55d7 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -5,7 +5,6 @@
 import fj.Unit;
 import fj.control.Trampoline;
 
-import static fj.P.lazy;
 import static fj.P.p;
 import static fj.control.Trampoline.suspend;
 import static fj.data.List.cons;
@@ -75,7 +74,7 @@ public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B
   }
 
   private static <S, A> State<S, A> suspended(F<S, Trampoline<P2<S, A>>> runF) {
-    return new State<>(s -> suspend(lazy(() -> runF.f(s))));
+    return new State<>(s -> suspend(() -> runF.f(s)));
   }
 
   private final F<S, Trampoline<P2<S, A>>> runF;
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index a5e30a9d..323995e1 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -16,7 +16,6 @@
 import static fj.Function.flip;
 import static fj.Monoid.intAdditionMonoid;
 import static fj.Ord.intOrd;
-import static fj.P.lazy;
 import static fj.P2.__1;
 import static fj.control.Trampoline.pure;
 import static fj.control.Trampoline.suspend;
@@ -551,7 +550,7 @@ final class Tramp {
 
             // Picks elements in constant stack space
             private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALength) {
-              return suspend(lazy(() ->
+              return suspend(() ->
                   (remainN == 0) ?
                       // We have picked N elements; stop
                       pure(nil()) :
@@ -559,7 +558,7 @@ private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALeng
                       (r.choose(0, remainALength - 1) < remainN) ?
                           tramp(remainAs.tail(), remainN - 1, remainALength - 1)
                               .map(pickedTail -> cons(remainAs.head(), pickedTail)) :
-                          tramp(remainAs.tail(), remainN, remainALength - 1)));
+                          tramp(remainAs.tail(), remainN, remainALength - 1));
             }
 
           }

From cf1188acafd62d60f1736a0d945790771029079b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 7 Oct 2018 11:13:26 +0200
Subject: [PATCH 219/336] Fix regression in lifted semigroup sum. Move lifted
 definition in Monoid.

---
 core/src/main/java/fj/Monoid.java     | 31 +++++++++++++++++++++++++++
 core/src/main/java/fj/Semigroup.java  | 24 +--------------------
 core/src/test/java/fj/MonoidTest.java | 19 ++++++++++++++++
 3 files changed, 51 insertions(+), 23 deletions(-)
 create mode 100644 core/src/test/java/fj/MonoidTest.java

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 3fcf1775..cdb8e746 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -17,6 +17,7 @@
 import static fj.data.List.nil;
 import static fj.data.Natural.natural;
 import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static fj.data.Stream.iterableStream;
 
 import java.math.BigInteger;
@@ -867,6 +868,36 @@ public List<A> sum(F0<Stream<List<A>>> as) {
     });
   }
 
+  /**
+   * Lift a {@code Semigroup<A>} for A to a {@code Monoid<Option<A>>}, using Option.none() as zero.
+   *
+   * @return A monoid for option.
+   */
+  public static <A> Monoid<Option<A>> optionMonoid(Semigroup<A> aSemigroup) {
+    return monoidDef(new Monoid.Definition<Option<A>>() {
+      @Override
+      public Option<A> empty() {
+        return none();
+      }
+
+      @Override
+      public Option<A> append(Option<A> a1, Option<A> a2) {
+        return a1.liftM2(a2, aSemigroup::sum).orElse(a1).orElse(a2);
+      }
+
+      @Override
+      public Option<A> multiply(int n, Option<A> oa) {
+        return n > 0 ? oa.map(a -> aSemigroup.multiply1p(n - 1, a)) : none();
+      }
+
+      @Override
+      public Option<A> sum(F0<Stream<Option<A>>> oas) {
+        Stream<A> as = oas.f().bind(Option::toStream);
+        return as.uncons(none(), h -> tail ->  some(aSemigroup.sumStream(h, tail::_1)));
+      }
+    });
+  }
+
   /**
    * A monoid for options.
    * @deprecated since 4.7. Use {@link #firstOptionMonoid()}.
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 16b0d130..f626ded7 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -172,29 +172,7 @@ public Semigroup<A> dual() {
    * Lifts the semigroup to obtain a trivial monoid.
    */
   public Monoid<Option<A>> lift() {
-    Definition<A> def = this.def;
-    return monoidDef(new Monoid.Definition<Option<A>>() {
-      @Override
-      public Option<A> empty() {
-        return none();
-      }
-
-      @Override
-      public Option<A> append(Option<A> a1, Option<A> a2) {
-        return a1.liftM2(a1, def::append).orElse(a1).orElse(a2);
-      }
-
-      @Override
-      public Option<A> multiply(int n, Option<A> oa) {
-        return n > 0 ? oa.map(a -> def.multiply1p(n - 1, a)) : none();
-      }
-
-      @Override
-      public Option<A> sum(F0<Stream<Option<A>>> oas) {
-        Stream<A> as = oas.f().bind(Option::toStream);
-        return as.uncons(none(), h -> tail ->  some(def.sum(h, tail::_1)));
-      }
-    });
+    return Monoid.optionMonoid(this);
   }
 
   /**
diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
new file mode 100644
index 00000000..8bab5315
--- /dev/null
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -0,0 +1,19 @@
+package fj;
+
+import fj.data.Option;
+import fj.data.Stream;
+import org.junit.Test;
+
+import static fj.data.Option.some;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class MonoidTest {
+
+  @Test
+  public void lifted_sum_of_two_numbers() {
+    Monoid<Option<Integer>> optionMonoid = Semigroup.intAdditionSemigroup.lift();
+    assertThat(optionMonoid.sum(some(3), some(5)), is(some(8)));
+    assertThat(optionMonoid.sumLeft(Stream.arrayStream(some(3), some(5))), is(some(8)));
+  }
+}

From c3ea5d36dd7869e8e4da411b4d9b926a44fb4bcd Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Sun, 7 Oct 2018 11:25:47 +0200
Subject: [PATCH 220/336] Add Trampoline.suspend(final F0<Trampoline<A>> a).

---
 core/src/main/java/fj/control/Trampoline.java | 17 ++++++++++++++---
 core/src/main/java/fj/data/DList.java         |  2 +-
 core/src/main/java/fj/data/Eval.java          |  6 +++---
 core/src/main/java/fj/data/List.java          |  2 +-
 core/src/main/java/fj/data/State.java         |  3 +--
 quickcheck/src/main/java/fj/test/Gen.java     |  5 ++---
 6 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 37491c3b..0b6060b1 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -46,7 +46,7 @@ public <R> R fold(final F<Normal<A>, R> n,
     // The monadic bind constructs a new Codense whose subcomputation is still `sub`, and Kleisli-composes the
     // continuations.
     public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
-      return codense(sub, o -> suspend(P.lazy(() -> cont.f(o).bind(f))));
+      return codense(sub, o -> suspend(() -> cont.f(o).bind(f)));
     }
 
     // The resumption of a Codense is the resumption of its subcomputation. If that computation is done, its result
@@ -126,6 +126,16 @@ public static <A> Trampoline<A> pure(final A a) {
     return new Pure<>(a);
   }
 
+  /**
+   * Suspends the given computation in a thunk.
+   *
+   * @param a A trampoline suspended in a thunk.
+   * @return A trampoline whose next step runs the given thunk.
+   */
+  public static <A> Trampoline<A> suspend(final F0<Trampoline<A>> a) {
+    return new Suspend<>(P.lazy(a));
+  }
+
   /**
    * Suspends the given computation in a thunk.
    *
@@ -136,6 +146,7 @@ public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
     return new Suspend<>(a);
   }
 
+
   /**
    * @return The first-class version of `suspend`.
    */
@@ -255,7 +266,7 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(P.lazy(() -> ta.zipWith(tb, f))))));
+        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(() -> ta.zipWith(tb, f)))));
       }
       for (final B y : eb.right()) {
         return suspend(x.map(ta -> ta.map(F2Functions.f(F2Functions.flip(f), y))));
@@ -263,7 +274,7 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     }
     for (final A x : ea.right()) {
       for (final B y : eb.right()) {
-        return suspend(P.lazy(() -> pure(f.f(x, y))));
+        return suspend(() -> pure(f.f(x, y)));
       }
       for (final P1<Trampoline<B>> y : eb.left()) {
         return suspend(y.map(liftM2(F2Functions.curry(f)).f(pure(x))));
diff --git a/core/src/main/java/fj/data/DList.java b/core/src/main/java/fj/data/DList.java
index af9d68b0..597b6dda 100644
--- a/core/src/main/java/fj/data/DList.java
+++ b/core/src/main/java/fj/data/DList.java
@@ -126,6 +126,6 @@ public DList<A> append(DList<A> other) {
     }
     
     private static <A,B,C> F<A,Trampoline<C>> kleisliTrampCompose(F<B,Trampoline<C>> bc, F<A,Trampoline<B>> ab) {
-        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(P.lazy(() -> bc.f(b))));
+        return (A a) -> ab.f(a).bind((B b) -> Trampoline.suspend(() -> bc.f(b)));
     }
 }
diff --git a/core/src/main/java/fj/data/Eval.java b/core/src/main/java/fj/data/Eval.java
index 3e513075..5d09f913 100644
--- a/core/src/main/java/fj/data/Eval.java
+++ b/core/src/main/java/fj/data/Eval.java
@@ -204,7 +204,7 @@ private static final class PureTrampolineEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> Trampoline.pure(start.value())));
+      return Trampoline.suspend(() -> Trampoline.pure(start.value()));
     }
   }
 
@@ -219,7 +219,7 @@ private static final class BindTrampolineEval<A, B> extends TrampolineEval<B> {
 
     @Override
     protected final Trampoline<B> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline())));
+      return Trampoline.suspend(() -> next.trampoline().bind(v -> f.f(v).asTrampoline().trampoline()));
     }
   }
 
@@ -232,7 +232,7 @@ private static final class DeferEval<A> extends TrampolineEval<A> {
 
     @Override
     protected final Trampoline<A> trampoline() {
-      return Trampoline.suspend(P.lazy(() -> memo._1().asTrampoline().trampoline()));
+      return Trampoline.suspend(() -> memo._1().asTrampoline().trampoline());
     }
   }
 }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index f58fd73f..e0e12877 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -736,7 +736,7 @@ public final <B> B foldRight(final F2<A, B, B> f, final B b) {
    * @return A Trampoline containing the final result after the right-fold reduction.
    */
   public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
-    return Trampoline.suspend(P.lazy(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head()))));
+    return Trampoline.suspend(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head())));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index 1b30a55e..f29d55d7 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -5,7 +5,6 @@
 import fj.Unit;
 import fj.control.Trampoline;
 
-import static fj.P.lazy;
 import static fj.P.p;
 import static fj.control.Trampoline.suspend;
 import static fj.data.List.cons;
@@ -75,7 +74,7 @@ public static <S, A, B> State<S, List<B>> traverse(List<A> list, F<A, State<S, B
   }
 
   private static <S, A> State<S, A> suspended(F<S, Trampoline<P2<S, A>>> runF) {
-    return new State<>(s -> suspend(lazy(() -> runF.f(s))));
+    return new State<>(s -> suspend(() -> runF.f(s)));
   }
 
   private final F<S, Trampoline<P2<S, A>>> runF;
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index a5e30a9d..323995e1 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -16,7 +16,6 @@
 import static fj.Function.flip;
 import static fj.Monoid.intAdditionMonoid;
 import static fj.Ord.intOrd;
-import static fj.P.lazy;
 import static fj.P2.__1;
 import static fj.control.Trampoline.pure;
 import static fj.control.Trampoline.suspend;
@@ -551,7 +550,7 @@ final class Tramp {
 
             // Picks elements in constant stack space
             private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALength) {
-              return suspend(lazy(() ->
+              return suspend(() ->
                   (remainN == 0) ?
                       // We have picked N elements; stop
                       pure(nil()) :
@@ -559,7 +558,7 @@ private Trampoline<List<A>> tramp(List<A> remainAs, int remainN, int remainALeng
                       (r.choose(0, remainALength - 1) < remainN) ?
                           tramp(remainAs.tail(), remainN - 1, remainALength - 1)
                               .map(pickedTail -> cons(remainAs.head(), pickedTail)) :
-                          tramp(remainAs.tail(), remainN, remainALength - 1)));
+                          tramp(remainAs.tail(), remainN, remainALength - 1));
             }
 
           }

From e1a0983a365ca6a934dccf14a181a9ba486ccdd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 23 Sep 2018 20:28:40 +0200
Subject: [PATCH 221/336] Add Strategy tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>

(cherry picked from commit 2e1f2c57176a2bf8974ef0725e681e9042cff9ec)
---
 .../fj/control/parallel/StrategyTest.java     | 61 +++++++++++++++++++
 core/src/test/java/fj/data/StreamTest.java    | 16 -----
 2 files changed, 61 insertions(+), 16 deletions(-)
 create mode 100644 core/src/test/java/fj/control/parallel/StrategyTest.java

diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
new file mode 100644
index 00000000..ee3b30df
--- /dev/null
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -0,0 +1,61 @@
+package fj.control.parallel;
+
+import fj.Ord;
+import fj.P;
+import fj.P1;
+import fj.data.Enumerator;
+import fj.data.List;
+import fj.data.Stream;
+import org.junit.Test;
+
+import java.util.concurrent.*;
+
+import static fj.control.parallel.Callables.callable;
+import static fj.control.parallel.Strategy.*;
+import static fj.data.Stream.range;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+public class StrategyTest {
+
+    @Test
+    public void testStrategySeq() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, seqStrategy()), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyThread() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        assertThat(s.sort(Ord.intOrd, simpleThreadStrategy()), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyExecutor() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        final ExecutorService es = Executors.newFixedThreadPool(10);
+        assertThat(s.sort(Ord.intOrd, executorStrategy(es)), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyCompletion() {
+        final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
+        final ExecutorService es = Executors.newFixedThreadPool(10);
+        final CompletionService cs = new ExecutorCompletionService(es);
+        assertThat(s.sort(Ord.intOrd, completionStrategy(cs)), is(s.sort(Ord.intOrd)));
+    }
+
+    @Test
+    public void testStrategyMergeAll() {
+        final List<Integer> l = List.range(0, 100);
+        final List<P1<Integer>> p1s = mergeAll(l.map(x -> CompletableFuture.supplyAsync(() -> x)));
+        assertThat(P1.sequence(p1s)._1(), is(l));
+    }
+
+    @Test
+    public void testStrategyCallables() throws Exception {
+        final Strategy<Callable<Integer>> s = strategy(c -> c);
+        final Strategy<Callable<Integer>> cs = callableStrategy(s);
+        assertThat(callableStrategy(s).par(P.p(callable(1)))._1().call(), is(1));
+    }
+}
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index b65e115c..999a3a3e 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -1,9 +1,7 @@
 package fj.data;
 
 import fj.Equal;
-import fj.Ord;
 import fj.P2;
-import fj.control.parallel.Strategy;
 import org.junit.Test;
 
 import java.util.ConcurrentModificationException;
@@ -105,18 +103,4 @@ public void testMinus() {
         assertThat(s1.minus(Equal.charEqual, s2),
                 is(stream(new Character[]{'a', 'c', 'd'})));
     }
-
-    @Test
-    public void testSortSeq() {
-        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
-        assertThat(s.sort(Ord.intOrd, Strategy.seqStrategy()),
-                is(s.sort(Ord.intOrd)));
-    }
-
-    @Test
-    public void testSortThread() {
-        Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
-        assertThat(s.sort(Ord.intOrd, Strategy.simpleThreadStrategy()),
-                is(s.sort(Ord.intOrd)));
-    }
 }

From 7b3cdae5e9d708904d72afffe039710ed8a9ad28 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb.giraudeau@lombardodier.com>
Date: Sun, 7 Oct 2018 20:00:44 +0200
Subject: [PATCH 222/336] Add missing @Deprecated annotations (previously only
 on javadoc).

---
 core/src/main/java/fj/P1.java        | 3 ++-
 core/src/main/java/fj/Semigroup.java | 3 ++-
 core/src/main/java/fj/data/Java.java | 1 +
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 555a28ae..5e627403 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -42,10 +42,11 @@ public static <A> F<P1<A>, A> __1() {
     /**
      * Promote any function to a transformation between P1s.
      *
-	 * @deprecated As of release 4.5, use {@link #map_}
+     * @deprecated As of release 4.5, use {@link #map_}
      * @param f A function to promote to a transformation between P1s.
      * @return A function promoted to operate on P1s.
      */
+    @Deprecated
     public static <A, B> F<P1<A>, P1<B>> fmap(final F<A, B> f) {
         return map_(f);
     }
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index f626ded7..075dfeda 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -527,8 +527,9 @@ public NonEmptyList<A> sum(NonEmptyList<A> nea, F0<Stream<NonEmptyList<A>>> neas
    * A semigroup for optional values.
    * @deprecated since 4.7. Use {@link #firstOptionSemigroup()}.
    *
-   ** @return A semigroup for optional values.
+   * @return A semigroup for optional values.
    */
+  @Deprecated
   public static <A> Semigroup<Option<A>> optionSemigroup() {
     return firstOptionSemigroup();
   }
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 80a5ec43..ae7fcf6a 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -1420,6 +1420,7 @@ public static <A> F<ArrayList<A>, List<A>> ArrayList_List() {
    *
    * @return A function that converts Java lists to lists.
    */
+  @Deprecated
   public static <A> F<java.util.List<A>, List<A>> JUList_List() {
     return Java::JavaList_List;
   }

From 9f489c9428ff06ea39400239faa929eae9d78bba Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb.giraudeau@lombardodier.com>
Date: Sun, 7 Oct 2018 21:08:42 +0200
Subject: [PATCH 223/336] Fix compile warnings.

---
 core/src/test/java/fj/FWFunctionsTest.java               | 4 ++--
 core/src/test/java/fj/TryEffectTest.java                 | 6 ++----
 core/src/test/java/fj/control/parallel/StrategyTest.java | 3 ++-
 props-core/src/test/java/fj/MemoisationTest.java         | 9 +++++----
 .../test/java/fj/data/fingertrees/FingerTreeTest.java    | 6 ++++--
 5 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/core/src/test/java/fj/FWFunctionsTest.java b/core/src/test/java/fj/FWFunctionsTest.java
index c1f69718..1c034ab9 100644
--- a/core/src/test/java/fj/FWFunctionsTest.java
+++ b/core/src/test/java/fj/FWFunctionsTest.java
@@ -9,14 +9,14 @@ public class FWFunctionsTest {
     @Test
     public void testLift1() {
         F<Integer, Integer> f = i -> i + 1;
-        F1W f1w = F1W.lift(f);
+        F1W<Integer, Integer> f1w = F1W.lift(f);
         assertThat(f1w.f(1), is(2));
     }
 
     @Test
     public void testLift2() {
         F2<Integer, Integer, Integer> f2 = (i, j) -> i + j;
-        F2W f2w = F2W.lift(f2);
+        F2W<Integer, Integer, Integer> f2w = F2W.lift(f2);
         assertThat(f2w.f(1, 2), is(3));
     }
 
diff --git a/core/src/test/java/fj/TryEffectTest.java b/core/src/test/java/fj/TryEffectTest.java
index bb684fc6..ea92b8f2 100644
--- a/core/src/test/java/fj/TryEffectTest.java
+++ b/core/src/test/java/fj/TryEffectTest.java
@@ -11,8 +11,7 @@ public class TryEffectTest {
 
     @Test
     public void testTryEffect0Success() {
-        F<TryEffect0, Validation<TryEffectException, Unit>> f =
-                TryEffect.f(TryEffect0<TryEffectException>::f);
+        F<TryEffect0<TryEffectException>, Validation<TryEffectException, Unit>> f = TryEffect.f(TryEffect0::f);
         Validation<TryEffectException, Unit> v = f.f(new AlwaysSucceed0());
         assertThat(v.isSuccess(), is(true));
         assertThat(v.success(), is(Unit.unit()));
@@ -20,8 +19,7 @@ public void testTryEffect0Success() {
 
     @Test
     public void testTryEffect0Fail() {
-        F<TryEffect0, Validation<TryEffectException, Unit>> f =
-                TryEffect.f(TryEffect0<TryEffectException>::f);
+        F<TryEffect0<TryEffectException>, Validation<TryEffectException, Unit>> f = TryEffect.f(TryEffect0::f);
         Validation<TryEffectException, Unit> v = f.f(new AlwaysFail0());
         assertThat(v.isFail(), is(true));
         assertThat(v.fail(), is(new TryEffectException()));
diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
index ee3b30df..8475b35a 100644
--- a/core/src/test/java/fj/control/parallel/StrategyTest.java
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -3,6 +3,7 @@
 import fj.Ord;
 import fj.P;
 import fj.P1;
+import fj.Unit;
 import fj.data.Enumerator;
 import fj.data.List;
 import fj.data.Stream;
@@ -41,7 +42,7 @@ public void testStrategyExecutor() {
     public void testStrategyCompletion() {
         final Stream<Integer> s = range(Enumerator.intEnumerator, 99, -99, -1);
         final ExecutorService es = Executors.newFixedThreadPool(10);
-        final CompletionService cs = new ExecutorCompletionService(es);
+        final CompletionService<Unit> cs = new ExecutorCompletionService<>(es);
         assertThat(s.sort(Ord.intOrd, completionStrategy(cs)), is(s.sort(Ord.intOrd)));
     }
 
diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
index 65fa83fc..865f76a3 100644
--- a/props-core/src/test/java/fj/MemoisationTest.java
+++ b/props-core/src/test/java/fj/MemoisationTest.java
@@ -6,6 +6,7 @@
 import org.junit.runner.RunWith;
 
 import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbString;
 import static fj.test.CheckResult.summary;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
@@ -25,16 +26,16 @@ public Property test1() {
     }
 
     public Property test1_hardMemo() {
-        return property(arbInteger, a -> {
-            P1<Integer> t = P.hardMemo(() -> new Integer(a));
+        return property(arbString, a -> {
+            P1<String> t = P.hardMemo(() -> new String(a));
             return prop(t._1() == t._1()).and(prop(t._1().equals(a)));
         });
     }
 
     @Test
     public Property test2() {
-        return property(arbInteger, arbInteger, (a, b) -> {
-            P2<Integer, Integer> t = P.lazy(u -> new Integer(a), u -> new Integer(b)).memo();
+        return property(arbString, arbString, (a, b) -> {
+            P2<String, String> t = P.lazy(u ->  new String(a), u -> new String(b)).memo();
             return prop(t._1().equals(t._1()) && t._1().equals(a) && t._2().equals(t._2()) && t._2().equals(b) );
         });
     }
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 57e1fae6..b25fff51 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -42,14 +42,16 @@ void validateOperations(List<Integer> list) {
     @Test
     public void testHeadOption() {
         assertThat(Empty.emptyIntAddition().headOption(), is(Option.none()));
-        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        FingerTree<Integer, Integer> ft = new MakeTree<Integer, Integer>(measured(intAdditionMonoid, Function.constant(1)))
+            .single(1);
         assertThat(ft.headOption(), is(Option.some(1)));
     }
 
     @Test
     public void testUncons() {
         assertThat(Empty.emptyIntAddition().uncons(0, (h, t) -> h), is(0));
-        FingerTree<Integer, Integer> ft = new MakeTree(measured(intAdditionMonoid, Function.constant(1))).single(1);
+        FingerTree<Integer, Integer> ft = new MakeTree<Integer, Integer>(measured(intAdditionMonoid, Function.constant(1)))
+            .single(1);
         assertThat(ft.uncons(0, (h, t) -> h), is(1));
     }
 

From 4c93bae8c23385b9d9acc0e2358073384a10ae03 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb.giraudeau@lombardodier.com>
Date: Sun, 7 Oct 2018 21:09:17 +0200
Subject: [PATCH 224/336] Update gradle. Fix gradle warnings.

---
 build.gradle                             |  24 ++++++++---------------
 gradle/wrapper/gradle-wrapper.jar        | Bin 54708 -> 56177 bytes
 gradle/wrapper/gradle-wrapper.properties |   3 +--
 3 files changed, 9 insertions(+), 18 deletions(-)

diff --git a/build.gradle b/build.gradle
index 9d98d2b3..bc292a82 100644
--- a/build.gradle
+++ b/build.gradle
@@ -21,6 +21,11 @@ buildscript {
         classpath "com.ofg:uptodate-gradle-plugin:$uptodateVersion"
         classpath "me.tatarka:gradle-retrolambda:$retrolambdaPluginVersion"
     }
+
+    wrapper {
+        gradleVersion = "4.10.2"
+        distributionType = Wrapper.DistributionType.ALL
+    }
 }
 
 if (JavaVersion.current().isJava8Compatible()) {
@@ -117,23 +122,10 @@ subprojects {
 		}
 	}
 
-    jacocoTestReport {
-        additionalSourceDirs = files(sourceSets.main.allSource.srcDirs)
-        sourceDirectories = files(sourceSets.main.allSource.srcDirs)
-        classDirectories =  files(sourceSets.main.output)
-        reports {
-            html.enabled = true
-            xml.enabled = true
-            csv.enabled = false
-        }
-    }
-
-    task coverage(dependsOn: ["test", "jacocoTestReport"]) << {}
-
 }
 
 task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
-    dependsOn = subprojects.coverage
+    dependsOn = subprojects*.test
     executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")
     // We only care about coverage of:
     def projectForFoverage = ["core", "java8", "quickcheck", "java-core"]
@@ -192,7 +184,7 @@ configure(subprojects.findAll { it.name != "props-core" }) {
     }
 
     // Output MANIFEST.MF statically so eclipse can see it for plugin development
-    task eclipsePluginManifest(dependsOn: jar) << {
+    task eclipsePluginManifest(dependsOn: jar) doLast {
       file("META-INF").mkdirs()
       jar.manifest.writeTo(file("META-INF/MANIFEST.MF"))
     }
@@ -200,6 +192,6 @@ configure(subprojects.findAll { it.name != "props-core" }) {
     eclipseProject.dependsOn eclipsePluginManifest
 }
 
-task env << {
+task env doLast {
 	println System.getenv()
 }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 7a3265ee94c0ab25cf079ac8ccdf87f41d455d42..29953ea141f55e3b8fc691d31b5ca8816d89fa87 100644
GIT binary patch
delta 50157
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
HXWjn;W&S@(

delta 48671
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 72c40576..d76b502e 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,5 @@
-#Sat Aug 25 14:20:05 CEST 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-all.zip

From b797968ae46d5eafd951b03c68d649b9aae8f654 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb.giraudeau@lombardodier.com>
Date: Sun, 7 Oct 2018 21:52:42 +0200
Subject: [PATCH 225/336] Fix javadoc warnings.

---
 core/src/main/java/fj/Function.java           | 28 +++++++++----------
 core/src/main/java/fj/Monoid.java             |  2 +-
 core/src/main/java/fj/Semigroup.java          |  2 +-
 core/src/main/java/fj/control/Trampoline.java | 12 ++++----
 core/src/main/java/fj/data/Enumerator.java    | 16 +++++------
 core/src/main/java/fj/data/Tree.java          |  4 ++-
 core/src/main/java/fj/data/hlist/HPre.java    |  4 +--
 core/src/main/java/fj/data/optic/Iso.java     |  4 +--
 core/src/main/java/fj/data/optic/PIso.java    | 16 +++++------
 core/src/main/java/fj/data/optic/PLens.java   | 26 +++++++++--------
 .../main/java/fj/data/optic/POptional.java    | 18 ++++++------
 core/src/main/java/fj/data/optic/PPrism.java  | 17 ++++++-----
 core/src/main/java/fj/data/optic/PSetter.java | 14 ++++++----
 .../main/java/fj/data/optic/PTraversal.java   |  6 ++--
 quickcheck/src/main/java/fj/test/Gen.java     | 12 ++++----
 15 files changed, 96 insertions(+), 85 deletions(-)

diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index f95b1c87..995c179d 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -778,11 +778,11 @@ public static <A, B> F<B, A> join(final F<B, F<B, A>> f) {
 
   /**
    * Partial application of the second argument to the supplied function to get a function of type
-   * <tt>A -> C</tt>. Same as <tt>flip(f).f(b)</tt>.
+   * {@code A -> C}. Same as {@code flip(f).f(b)}.
    *
    * @param f The function to partially apply.
    * @param b The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its second argument applied.
+   * @return A new function based on {@code f} with its second argument applied.
    */
   public static <A, B, C> F<A, C> partialApply2(final F<A, F<B, C>> f, final B b) {
     return a -> uncurryF2(f).f(a, b);
@@ -790,11 +790,11 @@ public static <A, B, C> F<A, C> partialApply2(final F<A, F<B, C>> f, final B b)
 
   /**
    * Partial application of the third argument to the supplied function to get a function of type
-   * <tt>A -> B -> D</tt>.
+   * {@code A -> B -> D}.
    *
    * @param f The function to partially apply.
    * @param c The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its third argument applied.
+   * @return A new function based on {@code f} with its third argument applied.
    */
   public static <A, B, C, D> F<A, F<B, D>> partialApply3(final F<A, F<B, F<C, D>>> f, final C c) {
     return a -> b -> uncurryF3(f).f(a, b, c);
@@ -802,11 +802,11 @@ public static <A, B, C, D> F<A, F<B, D>> partialApply3(final F<A, F<B, F<C, D>>>
 
   /**
    * Partial application of the fourth argument to the supplied function to get a function of type
-   * <tt>A -> B -> C -> E</tt>.
+   * {@code A -> B -> C -> E}.
    *
    * @param f The function to partially apply.
    * @param d The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its fourth argument applied.
+   * @return A new function based on {@code f} with its fourth argument applied.
    */
   public static <A, B, C, D, E> F<A, F<B, F<C, E>>> partialApply4(final F<A, F<B, F<C, F<D, E>>>> f, final D d) {
     return a -> b -> c -> uncurryF4(f).f(a, b, c, d);
@@ -814,11 +814,11 @@ public static <A, B, C, D, E> F<A, F<B, F<C, E>>> partialApply4(final F<A, F<B,
 
   /**
    * Partial application of the fifth argument to the supplied function to get a function of type
-   * <tt>A -> B -> C -> D -> F$</tt>.
+   * {@code A -> B -> C -> D -> F$}.
    *
    * @param f The function to partially apply.
    * @param e The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its fifth argument applied.
+   * @return A new function based on {@code f} with its fifth argument applied.
    */
   public static <A, B, C, D, E, F$> F<A, F<B, F<C, F<D, F$>>>> partialApply5(final F<A, F<B, F<C, F<D, F<E, F$>>>>> f,
                                                                              final E e) {
@@ -827,11 +827,11 @@ public static <A, B, C, D, E> F<A, F<B, F<C, E>>> partialApply4(final F<A, F<B,
 
   /**
    * Partial application of the sixth argument to the supplied function to get a function of type
-   * <tt>A -> B -> C -> D -> E -> G</tt>.
+   * {@code A -> B -> C -> D -> E -> G}.
    *
    * @param f  The function to partially apply.
    * @param f$ The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its sixth argument applied.
+   * @return A new function based on {@code f} with its sixth argument applied.
    */
   public static <A, B, C, D, E, F$, G> F<A, F<B, F<C, F<D, F<E, G>>>>> partialApply6(
       final F<A, F<B, F<C, F<D, F<E, F<F$, G>>>>>> f, final F$ f$) {
@@ -840,11 +840,11 @@ public static <A, B, C, D, E> F<A, F<B, F<C, E>>> partialApply4(final F<A, F<B,
 
   /**
    * Partial application of the seventh argument to the supplied function to get a function of type
-   * <tt>A -> B -> C -> D -> E -> F$ -> H</tt>.
+   * {@code A -> B -> C -> D -> E -> F$ -> H}.
    *
    * @param f The function to partially apply.
    * @param g The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its seventh argument applied.
+   * @return A new function based on {@code f} with its seventh argument applied.
    */
   public static <A, B, C, D, E, F$, G, H> F<A, F<B, F<C, F<D, F<E, F<F$, H>>>>>> partialApply7(
       final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, H>>>>>>> f, final G g) {
@@ -853,11 +853,11 @@ public static <A, B, C, D, E> F<A, F<B, F<C, E>>> partialApply4(final F<A, F<B,
 
   /**
    * Partial application of the eigth argument to the supplied function to get a function of type
-   * <tt>A -> B -> C -> D -> E -> F$ -> G -> I</tt>.
+   * {@code A -> B -> C -> D -> E -> F$ -> G -> I}.
    *
    * @param f The function to partially apply.
    * @param h The value to apply to the function.
-   * @return A new function based on <tt>f</tt> with its eigth argument applied.
+   * @return A new function based on {@code f} with its eigth argument applied.
    */
   public static <A, B, C, D, E, F$, G, H, I> F<A, F<B, F<C, F<D, F<E, F<F$, F<G, I>>>>>>> partialApply8(
       final F<A, F<B, F<C, F<D, F<E, F<F$, F<G, F<H, I>>>>>>>> f, final H h) {
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index cdb8e746..0c09b558 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -246,7 +246,7 @@ public A zero() {
   /**
    * Returns a value summed <code>n</code> times (<code>a + a + ... + a</code>).
    * The default definition uses peasant multiplication, exploiting
-   * associativity to only require `O(log n)` uses of
+   * associativity to only require {@code O(log n)} uses of
    * {@link #sum(Object, Object)}.
    *
    * @param n multiplier
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 075dfeda..42f05f5b 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -134,7 +134,7 @@ public F<A, F<A, A>> sum() {
   /**
    * Returns a value summed <code>n + 1</code> times (
    * <code>a + a + ... + a</code>) The default definition uses peasant
-   * multiplication, exploiting associativity to only require `O(log n)` uses of
+   * multiplication, exploiting associativity to only require {@code O(log n)} uses of
    * {@link #sum(Object, Object)}.
    *
    * @param n multiplier
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 0b6060b1..47fd282b 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -43,7 +43,7 @@ public <R> R fold(final F<Normal<A>, R> n,
       return gs.f(this);
     }
 
-    // The monadic bind constructs a new Codense whose subcomputation is still `sub`, and Kleisli-composes the
+    // The monadic bind constructs a new Codense whose subcomputation is still {@code sub}, and Kleisli-composes the
     // continuations.
     public <B> Trampoline<B> bind(final F<A, Trampoline<B>> f) {
       return codense(sub, o -> suspend(() -> cont.f(o).bind(f)));
@@ -110,7 +110,7 @@ private static <A, B> Codense<B> codense(final Normal<A> a, final F<A, Trampolin
   }
 
   /**
-   * @return The first-class version of `pure`.
+   * @return The first-class version of {@code pure}.
    */
   public static <A> F<A, Trampoline<A>> pure() {
     return Trampoline::pure;
@@ -148,7 +148,7 @@ public static <A> Trampoline<A> suspend(final P1<Trampoline<A>> a) {
 
 
   /**
-   * @return The first-class version of `suspend`.
+   * @return The first-class version of {@code suspend}.
    */
   public static <A> F<P1<Trampoline<A>>, Trampoline<A>> suspend_() {
     return Trampoline::suspend;
@@ -175,21 +175,21 @@ public final <B> Trampoline<B> map(final F<A, B> f) {
   }
 
   /**
-   * @return The first-class version of `bind`.
+   * @return The first-class version of {@code bind}.
    */
   public static <A, B> F<F<A, Trampoline<B>>, F<Trampoline<A>, Trampoline<B>>> bind_() {
     return f -> a -> a.bind(f);
   }
 
   /**
-   * @return The first-class version of `map`.
+   * @return The first-class version of {@code map}.
    */
   public static <A, B> F<F<A, B>, F<Trampoline<A>, Trampoline<B>>> map_() {
     return f -> a -> a.map(f);
   }
 
   /**
-   * @return The first-class version of `resume`.
+   * @return The first-class version of {@code resume}.
    */
   public static <A> F<Trampoline<A>, Either<P1<Trampoline<A>>, A>> resume_() {
     return Trampoline::resume;
diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index 1666d7b2..94f1b2cd 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -18,18 +18,18 @@
 
 /**
  * Abstracts over a type that may have a successor and/or predecessor value. This implies ordering for that type. A user
- * may construct an enumerator with an optimised version for <code>plus</code>, otherwise a default is implemented using
+ * may construct an enumerator with an optimised version for {@code plus}, otherwise a default is implemented using
  * the given successor/predecessor implementations.
  * <p/>
  * For any enumerator e, the following laws must satisfy:
  * <ul>
- * <li>forall a. e.successor(a).forall(\t -> e.predecessor(t).forall(\z -> z == a))</li>
- * <li>forall a. e.predecessor(a).forall(\t -> e.successor(t).forall(\z -> z == a))</li>
- * <li>e.max().forall(\t -> e.successor(t).isNone)</li>
- * <li>e.min().forall(\t -> e.predecessor(t).isNone)</li>
- * <li>forall a n. e.plus(a, 0) == Some(a)</li>
- * <li>forall a n | n > 0. e.plus(a, n) == e.plus(a, n - 1)</li>
- * <li>forall a n | n < 0. e.plus(a, n) == e.plus(a, n + 1)</li>
+ * <li>{@code forall a. e.successor(a).forall(\t -> e.predecessor(t).forall(\z -> z == a))}</li>
+ * <li>{@code forall a. e.predecessor(a).forall(\t -> e.successor(t).forall(\z -> z == a))}</li>
+ * <li>{@code e.max().forall(\t -> e.successor(t).isNone)}</li>
+ * <li>{@code e.min().forall(\t -> e.predecessor(t).isNone)}</li>
+ * <li>{@code forall a n. e.plus(a, 0) == Some(a)}</li>
+ * <li>{@code forall a n | n > 0. e.plus(a, n) == e.plus(a, n - 1)}</li>
+ * <li>{@code forall a n | n < 0. e.plus(a, n) == e.plus(a, n + 1)}</li>
  * </ul>
  *
  * @version %build.number%
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index 4b0ce7eb..9eebb932 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -134,8 +134,10 @@ public Stream<A> f(final Tree<A> t, final P1<Stream<A>> xs) {
   }
 
   /**
+   * <pre>{@code
    * flatten :: Tree a -> [a]
    * flatten t = squish t []
+   * }</pre>
    * where squish (Node x ts) xs = x:Prelude.foldr squish xs ts
    * Puts the elements of the tree into a Stream, in pre-order.
    *
@@ -346,4 +348,4 @@ public int length() {
         return 1 + subForest._1().map(Tree::length).foldLeft((acc, i) -> acc + i, 0);
     }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/fj/data/hlist/HPre.java b/core/src/main/java/fj/data/hlist/HPre.java
index 6a2556de..6c6174a4 100644
--- a/core/src/main/java/fj/data/hlist/HPre.java
+++ b/core/src/main/java/fj/data/hlist/HPre.java
@@ -57,7 +57,7 @@ public static HFalse hFalse() {
   }
 
   /**
-   * Type-level boolean conjunction. A value of this type represents evidence that AB -> C
+   * Type-level boolean conjunction. A value of this type represents evidence that {@code AB -> C}
    *
    * @param <A> A boolean
    * @param <B> A boolean
@@ -92,7 +92,7 @@ public static HAnd<HTrue, HTrue, HTrue> hAnd(final HTrue a, final HTrue b) {
   }
 
   /**
-   * Type-level boolean disjunction. A value of this type represents evidence that A+B -> C
+   * Type-level boolean disjunction. A value of this type represents evidence that {@code A+B -> C}
    *
    * @param <A> A boolean
    * @param <B> A boolean
diff --git a/core/src/main/java/fj/data/optic/Iso.java b/core/src/main/java/fj/data/optic/Iso.java
index ea9babac..4b41b1ad 100644
--- a/core/src/main/java/fj/data/optic/Iso.java
+++ b/core/src/main/java/fj/data/optic/Iso.java
@@ -119,10 +119,10 @@ public static <S, A> Iso<S, A> iso(final F<S, A> get, final F<A, S> reverseGet)
    * create an {@link Iso} between any type and itself. id is the zero element of optics composition, for all optics o of type O
    * (e.g. Lens, Iso, Prism, ...):
    *
-   * <pre>
+   * <pre>{@code
    *  o composeIso Iso.id == o
    *  Iso.id composeO o == o
-   * </pre>
+   * }</pre>
    *
    * (replace composeO by composeLens, composeIso, composePrism, ...)
    */
diff --git a/core/src/main/java/fj/data/optic/PIso.java b/core/src/main/java/fj/data/optic/PIso.java
index e10b47bb..b97b416f 100644
--- a/core/src/main/java/fj/data/optic/PIso.java
+++ b/core/src/main/java/fj/data/optic/PIso.java
@@ -21,18 +21,18 @@
 /**
  * A {@link PIso} defines an isomorphism between types S, A and B, T:
  *
- * <pre>
+ * <pre>{@code
  *              get                           reverse.get
  *     -------------------->             -------------------->
  *   S                       A         T                       B
  *     <--------------------             <--------------------
  *       reverse.reverseGet                   reverseGet
- * </pre>
+ * }</pre>
  *
- * In addition, if f and g forms an isomorphism between `A` and `B`, i.e. if `f . g = id` and `g . f = id`, then a {@link PIso}
- * defines an isomorphism between `S` and `T`:
+ * In addition, if f and g forms an isomorphism between {@code A} and {@code B}, i.e. if {@code f . g = id} and {@code g . f = id}, then a {@link PIso}
+ * defines an isomorphism between {@code S} and {@code T}:
  *
- * <pre>
+ * <pre>{@code
  *     S           T                                   S           T
  *     |           |                                   |           |
  *     |           |                                   |           |
@@ -40,7 +40,7 @@
  *     |           |                                   |           |
  *     |     f     |                                   |     g     |
  *     A --------> B                                   A <-------- B
- * </pre>
+ * }</pre>
  *
  * A {@link PIso} is also a valid {@link Getter}, {@link Fold}, {@link PLens}, {@link PPrism}, {@link POptional},
  * {@link PTraversal} and {@link PSetter}
@@ -552,10 +552,10 @@ public PIso<S, T, A, B> reverse() {
    * create a {@link PIso} between any type and itself. id is the zero element of optics composition, for all optics o of type O
    * (e.g. Lens, Iso, Prism, ...):
    *
-   * <pre>
+   * <pre>{@code
    *  o composeIso Iso.id == o
    *  Iso.id composeO o == o
-   * </pre>
+   * }</pre>
    *
    * (replace composeO by composeLens, composeIso, composePrism, ...)
    */
diff --git a/core/src/main/java/fj/data/optic/PLens.java b/core/src/main/java/fj/data/optic/PLens.java
index 971f76ff..4dcad20b 100644
--- a/core/src/main/java/fj/data/optic/PLens.java
+++ b/core/src/main/java/fj/data/optic/PLens.java
@@ -17,18 +17,20 @@
 import fj.data.vector.V2;
 
 /**
- * A {@link PLens} can be seen as a pair of functions: - `get: S => A` i.e. from an `S`, we can extract an `A` - `set: (B, S) =>
- * T` i.e. if we replace an `A` by a `B` in an `S`, we obtain a `T`
- *
- * A {@link PLens} could also be defined as a weaker {@link PIso} where set requires an additional parameter than reverseGet.
- *
- * {@link PLens} stands for Polymorphic Lens as it set and modify methods change a type `A` to `B` and `S` to `T`. {@link Lens}
- * is a {@link PLens} restricted to monomoprhic updates.
- *
- * A {@link PLens} is also a valid {@link Getter}, {@link Fold}, {@link POptional}, {@link PTraversal} and {@link PSetter}
- *
+ * A {@link PLens} can be seen as a pair of functions:<ul>
+ *  <li>{@code get: S => A} i.e. from an {@code S}, we can extract an {@code A}</li>
+ *  <li>{@code set: (B, S) => T} i.e. if we replace an {@code A} by a {@code B} in an {@code S}, we obtain a {@code T}</li>
+ *  </ul>
+ * <p>
+ * A {@link PLens} could also be defined as a weaker {@link PIso} where set requires an additional parameter than reverseGet.</p>
+ * <p>
+ * {@link PLens} stands for Polymorphic Lens as it set and modify methods change a type {@code A} to {@code B} and {@code S} to {@code T}. {@link Lens}
+ * is a {@link PLens} restricted to monomoprhic updates.</p>
+ * <p>
+ * A {@link PLens} is also a valid {@link Getter}, {@link Fold}, {@link POptional}, {@link PTraversal} and {@link PSetter}</p>
+ * <p>
  * Typically a {@link PLens} or {@link Lens} can be defined between a Product (e.g. case class, tuple, HList) and one of it is
- * component.
+ * component.</p>
  *
  * @param <S> the source of a {@link PLens}
  * @param <T> the modified source of a {@link PLens}
@@ -500,4 +502,4 @@ public F<S, T> modify(final F<A, B> f) {
       }
     };
   }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/fj/data/optic/POptional.java b/core/src/main/java/fj/data/optic/POptional.java
index d35979d8..c70aa4c1 100644
--- a/core/src/main/java/fj/data/optic/POptional.java
+++ b/core/src/main/java/fj/data/optic/POptional.java
@@ -20,13 +20,15 @@
 import fj.data.vector.V2;
 
 /**
- * A {@link POptional} can be seen as a pair of functions: - `getOrModify: S => T \/ A` - `set : (B, S) => T`
- *
- * A {@link POptional} could also be defined as a weaker {@link PLens} and weaker {@link PPrism}
- *
- * {@link POptional} stands for Polymorphic Optional as it set and modify methods change a type `A` to `B` and `S` to `T`.
- * {@link Optional} is a {@link POptional} restricted to monomoprhic updates: {{{ type Optional[S, A] = POptional[S, S, A, A]
- * }}}
+ * A {@link POptional} can be seen as a pair of functions:<ul>
+ *  <li>{@code getOrModify: S => T \/ A}</li>
+ *  <li>{@code set : (B, S) => T}</li>
+ *  </ul>
+ * <p>
+ * A {@link POptional} could also be defined as a weaker {@link PLens} and weaker {@link PPrism}</p>
+ * <p>
+ * {@link POptional} stands for Polymorphic Optional as it set and modify methods change a type {@code A} to {@code B} and {@code S} to {@code T}.
+ * {@link Optional} is a {@link POptional} restricted to monomoprhic updates: {@code type Optional[S, A] = POptional[S, S, A, A]}</p>
  *
  * @param <S> the source of a {@link POptional}
  * @param <T> the modified source of a {@link POptional}
@@ -479,4 +481,4 @@ public F<S, T> modify(final F<A, B> f) {
     };
   }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/fj/data/optic/PPrism.java b/core/src/main/java/fj/data/optic/PPrism.java
index c4a65a68..ffa87ba6 100644
--- a/core/src/main/java/fj/data/optic/PPrism.java
+++ b/core/src/main/java/fj/data/optic/PPrism.java
@@ -19,14 +19,17 @@
 import fj.data.vector.V2;
 
 /**
- * A {@link PPrism} can be seen as a pair of functions: - `getOrModify: S => T \/ A` - `reverseGet : B => T`
- *
- * A {@link PPrism} could also be defined as a weaker {@link PIso} where get can fail.
- *
+ * A {@link PPrism} can be seen as a pair of functions:<ul>
+ *  <li>{@code getOrModify: S => T \/ A}</li>
+ *  <li>{@code reverseGet : B => T}</li>
+ * </ul>
+ * <p>
+ * A {@link PPrism} could also be defined as a weaker {@link PIso} where get can fail.</p>
+ * <p>
  * Typically a {@link PPrism} or {@link Prism} encodes the relation between a Sum or CoProduct type (e.g. sealed trait) and one
- * of it is element.
+ * of it is element.</p>
  *
- * {@link PPrism} stands for Polymorphic Prism as it set and modify methods change a type `A` to `B` and `S` to `T`.
+ * {@link PPrism} stands for Polymorphic Prism as it set and modify methods change a type {@code A} to {@code B} and {@code S} to {@code T}.
  * {@link Prism} is a {@link PPrism} where the type of target cannot be modified.
  *
  * A {@link PPrism} is also a valid {@link Fold}, {@link POptional}, {@link PTraversal} and {@link PSetter}
@@ -436,4 +439,4 @@ public Option<A> getOption(final S s) {
     };
   }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/fj/data/optic/PSetter.java b/core/src/main/java/fj/data/optic/PSetter.java
index 012920cb..13be7739 100644
--- a/core/src/main/java/fj/data/optic/PSetter.java
+++ b/core/src/main/java/fj/data/optic/PSetter.java
@@ -5,12 +5,14 @@
 import fj.data.Either;
 
 /**
- * A {@link PSetter} is a generalisation of Functor map: - `map: (A => B) => F[A] => F[B]` - `modify: (A => B) => S =>
- * T`
- *
- * {@link PSetter} stands for Polymorphic Setter as it set and modify methods change a type `A` to `B` and `S` to `T`.
- *
- * {@link PTraversal}, {@link POptional}, {@link PPrism}, {@link PLens} and {@link PIso} are valid {@link PSetter}
+ * A {@link PSetter} is a generalisation of Functor map:<ul>
+ * <li>{@code map: (A => B) => F[A] => F[B]}</li>
+ * <li>{@code modify: (A => B) => S => T}</li>
+ * </ul>
+ * <p>
+ * {@link PSetter} stands for Polymorphic Setter as it set and modify methods change a type {@code A} to {@code B} and {@code S} to {@code T}.</p>
+ * <p>
+ * {@link PTraversal}, {@link POptional}, {@link PPrism}, {@link PLens} and {@link PIso} are valid {@link PSetter}</p>
  *
  * @param <S> the source of a {@link PSetter}
  * @param <T> the modified source of a {@link PSetter}
diff --git a/core/src/main/java/fj/data/optic/PTraversal.java b/core/src/main/java/fj/data/optic/PTraversal.java
index ee16760f..6087f707 100644
--- a/core/src/main/java/fj/data/optic/PTraversal.java
+++ b/core/src/main/java/fj/data/optic/PTraversal.java
@@ -24,9 +24,9 @@
 
 /**
  * A {@link PTraversal} can be seen as a {@link POptional} generalised to 0 to n targets where n can be infinite.
- *
- * {@link PTraversal} stands for Polymorphic Traversal as it set and modify methods change a type `A` to `B` and `S` to `T`.
- * {@link Traversal} is a {@link PTraversal} restricted to monomoprhic updates.
+ * <p>
+ * {@link PTraversal} stands for Polymorphic Traversal as it set and modify methods change a type {@code A} to {@code B} and {@code S} to {@code T}.
+ * {@link Traversal} is a {@link PTraversal} restricted to monomoprhic updates.</p>
  *
  * @param <S> the source of a {@link PTraversal}
  * @param <T> the modified source of a {@link PTraversal}
diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 323995e1..c375874d 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -33,7 +33,7 @@
  * allowing various forms of composition of generators. </p> <p> A user typically creates an {@link
  * Arbitrary arbitrary} to return a generator using the 'combinator methods' below. For example,
  * suppose a <code>class Person</code>:
-<pre>
+<pre>{@code
 class Person {
   final int age;
   final String name;
@@ -45,23 +45,23 @@ class Person {
     this.male = male;
   }
 }
-</pre>
+}</pre>
  * </p> <p> In a case like this one, a user may create a generator over <code>Person</code> by
  * invoking the {@link #bind(F)}  methods &mdash; in this case, {@link #bind(Gen , Gen , F)} the one
  * that takes two generator arguments}, since the class has one more than two fields (the bind
  * method is invoked on a generator adding the extra one to the count as they are composed). The
  * class fields are of types for which there exist generators (on {@link Gen} so those can be
  * used to compose a generator for <code>Person</code>: </p>
-<pre>
+<pre>{@code
 static Gen&lt;Person&gt; personArbitrary() {
   return arbInteger.bind(arbString(), arbBoolean(),
       // compose the generators
       {int age =&gt; {String name =&gt; {boolean male =&gt; new Person(age, name, male)}}};
 }
-</pre>
+}</pre>
  * <p/>
  * The example above uses Java 7 closure syntax. Here is the same example using objects instead:
-<pre>
+<pre>{@code
 static Gen&lt;Person&gt; personArbitrary() {
   return arbInteger.bind(arbString, arbBoolean,
       // compose the generators
@@ -79,7 +79,7 @@ public Person f(final Boolean male) {
         }
       });
 }
-</pre>
+}</pre>
  *
  * @version %build.number%
  */

From 6dd03d708f5d04c4f3c0fe4ba25eab39cd075073 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 8 Oct 2018 14:21:40 +0200
Subject: [PATCH 226/336] html5 javadoc

---
 build.gradle | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/build.gradle b/build.gradle
index 6104c093..c070903d 100644
--- a/build.gradle
+++ b/build.gradle
@@ -140,6 +140,10 @@ configure(subprojects.findAll { it.name != "props-core" }) {
 
     sourceCompatibility = "1.8"
 
+    javadoc {
+        options.addBooleanOption('html5', true)
+    }
+
     task javadocJar(type: Jar, dependsOn: "javadoc") {
         classifier = 'javadoc'
         from "build/docs/javadoc"

From cd201cce91343302d928f72d31ead35021261de9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 8 Oct 2018 17:35:49 +0200
Subject: [PATCH 227/336] 4.8.1 release.

---
 README.adoc  | 18 +++++++++---------
 build.gradle |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/README.adoc b/README.adoc
index a7e2d3a4..8a3ad347 100644
--- a/README.adoc
+++ b/README.adoc
@@ -35,12 +35,12 @@ The Functional Java artifact is published to Maven Central using the group `org.
 * Java 8 specific support (`functionaljava-java8`)
 * property based testing (`functionaljava-quickcheck` or `functionaljava-quickcheck_1.8` if you use Java 8+)
 
-The latest stable version is `4.8`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `4.8.1`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.8"
-compile "org.functionaljava:functionaljava-java8:4.8"
-compile "org.functionaljava:functionaljava-quickcheck:4.8"
-compile "org.functionaljava:functionaljava-java-core:4.8"
+compile "org.functionaljava:functionaljava:4.8.1"
+compile "org.functionaljava:functionaljava-java8:4.8.1"
+compile "org.functionaljava:functionaljava-quickcheck:4.8.1"
+compile "org.functionaljava:functionaljava-java-core:4.8.1"
 ----
 
 and in Maven:
@@ -48,22 +48,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.8</version>
+    <version>4.8.1</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java8</artifactId>
-    <version>4.8</version>
+    <version>4.8.1</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.8</version>
+    <version>4.8.1</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java-core</artifactId>
-    <version>4.8</version>
+    <version>4.8.1</version>
 </dependency>
 ----
 
diff --git a/build.gradle b/build.gradle
index bc292a82..d6c26032 100644
--- a/build.gradle
+++ b/build.gradle
@@ -47,8 +47,8 @@ allprojects {
 	defaultTasks "build"
 
     ext {
-        isSnapshot = true
-        fjBaseVersion = "4.9"
+        isSnapshot = false
+        fjBaseVersion = "4.8.1"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")

From e32fbfdfee3b0f939ec3a9a83cb2c2d094ff3f64 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 8 Oct 2018 17:39:52 +0200
Subject: [PATCH 228/336] Set version to 4.9-SNAPSHOT

---
 build.gradle | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index d6c26032..67d8cd15 100644
--- a/build.gradle
+++ b/build.gradle
@@ -47,12 +47,12 @@ allprojects {
 	defaultTasks "build"
 
     ext {
-        isSnapshot = false
-        fjBaseVersion = "4.8.1"
+        isSnapshot = true
+        fjBaseVersion = "4.9"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.8"
+        fjConsumeVersion = "4.8.1"
 
         signModule = false
         useRetroLambda = false

From fcff9d1dc166943906aaa837b26478e74814bfd9 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Giraudeau <jb@giraudeau.info>
Date: Mon, 8 Oct 2018 18:11:11 +0200
Subject: [PATCH 229/336] Update changelog with 4.8.1 changes.

---
 ChangeLog.md | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/ChangeLog.md b/ChangeLog.md
index 24276f35..acdbedea 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,23 @@
+4.8.1
+-----
+
+### Enhancements
+
+- Add Trampoline.suspend(final F0<Trampoline<A>> a). (see [#367](https://github.com/functionaljava/functionaljava/pull/367));
+
+### Fixes
+
+- Fix regression in lifted semigroup sum. Fix #365 (see [#366](https://github.com/functionaljava/functionaljava/pull/366));
+
+### Internal
+
+- Fix compile under jdk11. Enable jdk11 travis build. (see [#361](https://github.com/functionaljava/functionaljava/pull/361));
+- Fix warnings (see [#369](https://github.com/functionaljava/functionaljava/pull/369));
+- Add P tests (see [#360](https://github.com/functionaljava/functionaljava/pull/360));
+- Exclude consume/ from coverage (see [#357](https://github.com/functionaljava/functionaljava/pull/357));
+- Add DList tests (see [#356](https://github.com/functionaljava/functionaljava/pull/356));
+- Add Visitor tests (see [#354](https://github.com/functionaljava/functionaljava/pull/354));
+
 4.8
 ---
 
@@ -20,7 +40,6 @@
 - Added Scalacheck Arbitrary implementations for Natural and NonEmptyList. (see [`405c3ec`](https://github.com/functionaljava/functionaljava/commit/405c3ec));
 - Added unit test coverage for Semigroup implementations.  The StringBuffer and StringBuilder tests fail because both of those types are mutable.  The IO test fails because the ArbitraryIO implementation does not implement equals. (see [`ef81130`](https://github.com/functionaljava/functionaljava/commit/ef81130));
 - Fixed the ArbitraryIO implementation and created a Properties object for testing the IO semigroup. (see [`a8e979f`](https://github.com/functionaljava/functionaljava/commit/a8e979f));
-- Added working tests coverage for the StringBuffer and StringBuilder semigroup implementations.  Added the Semigroup tests to the list of Scalacheck test suite. (see [`aa4de33`](https://github.com/functionaljava/functionaljava/commit/aa4de33));
 - Equal: remove reference to static field of LazyString. Fix #321 (see [`6c6dabd`](https://github.com/functionaljava/functionaljava/commit/6c6dabd));
 - Add IOFunctions tests (see [#340](https://github.com/functionaljava/functionaljava/pull/340));
 - Add Stream tests (see [#341](https://github.com/functionaljava/functionaljava/pull/341));
@@ -30,4 +49,4 @@
 - Add Parser tests (see [#349](https://github.com/functionaljava/functionaljava/pull/349));
 - Add FingerTree tests (see [#351](https://github.com/functionaljava/functionaljava/pull/351));
 - Add TreeZipper tests (see [#352](https://github.com/functionaljava/functionaljava/pull/352));
-- Add Reader/Writer tests (see [#353](https://github.com/functionaljava/functionaljava/pull/353));
\ No newline at end of file
+- Add Reader/Writer tests (see [#353](https://github.com/functionaljava/functionaljava/pull/353));

From 86dabd508306a2cc78fbb692994e158420926c8d Mon Sep 17 00:00:00 2001
From: SoundharyaKamaraj <ksoundharya@gmail.com>
Date: Thu, 25 Oct 2018 12:37:50 -0400
Subject: [PATCH 230/336] #371: fixed failing property test  (#373)

---
 .../src/test/java/fj/data/hamt/BitSetProperties.java      | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
index f3527972..6c3f91a9 100644
--- a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
+++ b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
@@ -156,15 +156,19 @@ Property rangeTest() {
             int h = list.index(2);
             int m = Math.max(l, Math.min(list.index(1), h - 1));
             int vh = list.index(3);
-
+            
             BitSet bs1 = longBitSet(x);
             BitSet bs2 = bs1.range(l, h);
+            if(l==h){
+            	return prop(true);
+            }
             boolean b =
-                bs1.isSet(m) == bs2.isSet(m - l) &&
+            	bs1.isSet(m) == bs2.isSet(m - l) &&
                 bs2.isSet(vh - l) == false;
             return prop(b);
         });
     }
+    
 
     Property setTest() {
         return property(arbNaturalLong, arbBitSetSize, (l, i) -> prop(longBitSet(l).set(i).isSet(i)));

From c0f0fdbc6ba6e0dd1043fe63d07af4cac6a0c5a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 15 Dec 2018 22:21:15 -0500
Subject: [PATCH 231/336] Add Validation tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/data/Validation.java    |   8 +-
 .../src/test/java/fj/data/ValidationTest.java | 244 ++++++++++++++++++
 2 files changed, 248 insertions(+), 4 deletions(-)
 create mode 100644 core/src/test/java/fj/data/ValidationTest.java

diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 58aa5e9c..0b939e57 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -783,7 +783,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
 
 
     public final <B, C, D, $E, $F, G> Validation<List<E>, G> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, F6<T, B, C, D, $E, $F, G> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
@@ -792,7 +792,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
     }
 
     public final <B, C, D, $E, $F, G, H> Validation<List<E>, H> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, F7<T, B, C, D, $E, $F, G, H> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6, v7));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
@@ -801,7 +801,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
     }
 
     public final <B, C, D, $E, $F, G, H, I> Validation<List<E>, I> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, Validation<E, H> v8, F8<T, B, C, D, $E, $F, G, H, I> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6, v7, v8));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
@@ -860,7 +860,7 @@ public static <A, E> List<E> fails(List<Validation<E, ?>> list) {
         return list.filter(Validation::isFail).map(v -> v.fail());
     }
 
-    public static <A, E> List<A> successes(List<Validation<?, A>> list) {
+    public static <A, E> List<A> successes(List<Validation<E, A>> list) {
         return list.filter(Validation::isSuccess).map(v -> v.success());
     }
 
diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
new file mode 100644
index 00000000..2d90c9e4
--- /dev/null
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -0,0 +1,244 @@
+package fj.data;
+
+import org.junit.Test;
+
+import static fj.data.Validation.*;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import fj.*;
+
+public class ValidationTest {
+    @Test
+    public void testParseShort() {
+        final List<Validation<NumberFormatException, Short>> l =
+                List.list(parseShort("10"), parseShort("x"), parseShort("20"));
+        assertThat(successes(l).foldLeft1((s, a) -> (short)(s + a)), is((short)30));
+    }
+
+    @Test
+    public void testParseLong() {
+        final List<Validation<NumberFormatException, Long>> l =
+                List.list(parseLong("10"), parseLong("x"), parseLong("20"));
+        P2<List<NumberFormatException>, List<Long>> p2 = partition(l);
+        assertThat(p2._1().length(), is(1));
+        assertThat(p2._2().length(), is(2));
+    }
+
+    @Test
+    public void testParseInt() {
+        final List<Validation<NumberFormatException, Integer>> l =
+                List.list(parseInt("10"), parseInt("x"), parseInt("20"));
+        assertThat(l.map(v -> v.validation(e -> 0, i -> 1)).foldLeft1((s, a) -> s + a),
+                is(2));
+    }
+
+    @Test
+    public void testParseFloat() {
+        final List<Validation<NumberFormatException, Float>> l =
+                List.list(parseFloat("2.0"), parseFloat("x"), parseFloat("3.0"));
+        assertThat(l.map(v -> v.validation(e -> 0, i -> 1)).foldLeft1((s, a) -> s + a),
+                is(2));
+    }
+
+    @Test
+    public void testParseByte() {
+        final List<Validation<NumberFormatException, Byte>> l =
+                List.list(parseByte("10"), parseByte("x"), parseByte("-10"));
+        assertThat(l.map(v -> v.validation(e -> 0, i -> 1)).foldLeft1((s, a) -> s + a),
+                is(2));
+    }
+
+    @Test
+    public void testAccumulate1() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("10.0").accumulate(
+                        f1 -> f1);
+        assertThat(v.success(), is(10.0));
+    }
+
+    @Test
+    public void testAccumulate1Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        f1 -> f1);
+        assertThat(v.fail().length(), is(1));
+    }
+
+    @Test
+    public void testAccumulate2() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        (f1, f2) -> f1 + f2);
+        assertThat(v.success(), is(3.0));
+    }
+
+    @Test
+    public void testAccumulate2Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("y"),
+                        (f1, f2) -> f1 + f2);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate3() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        (f1, f2, f3) -> f1 + f2 + f3);
+        assertThat(v.success(), is(6.0));
+    }
+
+    @Test
+    public void testAccumulate3Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3) -> f1 + f2 + f3);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate4() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        (f1, f2, f3, f4) -> f1 + f2 + f3 + f4);
+        assertThat(v.success(), is(10.0));
+    }
+
+    @Test
+    public void testAccumulate4Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3, f4) -> f1 + f2 + f3 + f4);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate5() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        (f1, f2, f3, f4, f5) -> f1 + f2 + f3 + f4 + f5);
+        assertThat(v.success(), is(15.0));
+    }
+
+    @Test
+    public void testAccumulate5Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3, f4, f5) -> f1 + f2 + f3 + f4 + f5);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate6() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("6.0"),
+                        (f1, f2, f3, f4, f5, f6) -> f1 + f2 + f3 + f4 + f5 + f6);
+        assertThat(v.success(), is(21.0));
+    }
+
+    @Test
+    public void testAccumulate6Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3, f4, f5, f6) -> f1 + f2 + f3 + f4 + f5 + f6);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate7() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("6.0"),
+                        parseDouble("7.0"),
+                        (f1, f2, f3, f4, f5, f6, f7) -> f1 + f2 + f3 + f4 + f5 + f6 + f7);
+        assertThat(v.success(), is(28.0));
+    }
+
+    @Test
+    public void testAccumulate7Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("6.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3, f4, f5, f6, f7) -> f1 + f2 + f3 + f4 + f5 + f6 + f7);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test
+    public void testAccumulate8() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("1.0").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("6.0"),
+                        parseDouble("7.0"),
+                        parseDouble("8.0"),
+                        (f1, f2, f3, f4, f5, f6, f7, f8) -> f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8);
+        assertThat(v.success(), is(36.0));
+    }
+
+    @Test
+    public void testAccumulate8Fail() {
+        final Validation<List<NumberFormatException>, Double> v =
+                parseDouble("x").accumulate(
+                        parseDouble("2.0"),
+                        parseDouble("3.0"),
+                        parseDouble("4.0"),
+                        parseDouble("5.0"),
+                        parseDouble("6.0"),
+                        parseDouble("7.0"),
+                        parseDouble("y"),
+                        (f1, f2, f3, f4, f5, f6, f7, f8) -> f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8);
+        assertThat(v.fail().length(), is(2));
+    }
+
+    @Test(expected = Error.class)
+    public void testSuccess() {
+        parseShort("x").success();
+    }
+
+    @Test(expected = Error.class)
+    public void testFail() {
+        parseShort("12").fail();
+    }
+}

From 0e8e15232f4953a9396e7b30e5664dc1fb513a12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 16 Dec 2018 13:35:39 -0500
Subject: [PATCH 232/336] Additional Validation tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 .../src/test/java/fj/data/ValidationTest.java | 76 ++++++++++++++++++-
 1 file changed, 75 insertions(+), 1 deletion(-)

diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
index 2d90c9e4..2f438e5c 100644
--- a/core/src/test/java/fj/data/ValidationTest.java
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -1,11 +1,12 @@
 package fj.data;
 
+import fj.P2;
 import org.junit.Test;
 
+import static fj.Semigroup.firstSemigroup;
 import static fj.data.Validation.*;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
-import fj.*;
 
 public class ValidationTest {
     @Test
@@ -232,6 +233,47 @@ public void testAccumulate8Fail() {
         assertThat(v.fail().length(), is(2));
     }
 
+    @Test
+    public void testAccumulate8s() {
+        final Validation<NumberFormatException, Integer> v1 = parseInt("1");
+        final Validation<NumberFormatException, Integer> v2 = parseInt("2");
+        final Validation<NumberFormatException, Integer> v3 = parseInt("3");
+        final Validation<NumberFormatException, Integer> v4 = parseInt("4");
+        final Validation<NumberFormatException, Integer> v5 = parseInt("5");
+        final Validation<NumberFormatException, Integer> v6 = parseInt("6");
+        final Validation<NumberFormatException, Integer> v7 = parseInt("7");
+        final Validation<NumberFormatException, Integer> v8 = parseInt("8");
+        final Option<NumberFormatException> on2 = v1.accumulate(firstSemigroup(), v2);
+        assertThat(on2, is(Option.none()));
+        final Option<NumberFormatException> on3 = v1.accumulate(firstSemigroup(), v2, v3);
+        assertThat(on3, is(Option.none()));
+        final Option<NumberFormatException> on4 = v1.accumulate(firstSemigroup(), v2, v3, v4);
+        assertThat(on4, is(Option.none()));
+        final Option<NumberFormatException> on5 = v1.accumulate(firstSemigroup(), v2, v3, v4, v5);
+        assertThat(on5, is(Option.none()));
+        final Option<NumberFormatException> on6 = v1.accumulate(firstSemigroup(), v2, v3, v4, v5, v6);
+        assertThat(on6, is(Option.none()));
+        final Option<NumberFormatException> on7 = v1.accumulate(firstSemigroup(), v2, v3, v4, v5, v6, v7);
+        assertThat(on7, is(Option.none()));
+        final Option<NumberFormatException> on8 = v1.accumulate(firstSemigroup(), v2, v3, v4, v5, v6, v7, v8);
+        assertThat(on8, is(Option.none()));
+    }
+
+    @Test
+    public void testAccumulate8sFail() {
+        final Option<NumberFormatException> on =
+                parseInt("x").accumulate(
+                        firstSemigroup(),
+                        parseInt("2"),
+                        parseInt("3"),
+                        parseInt("4"),
+                        parseInt("5"),
+                        parseInt("6"),
+                        parseInt("7"),
+                        parseInt("y"));
+        assertThat(on.some().getMessage(), is("For input string: \"x\""));
+    }
+
     @Test(expected = Error.class)
     public void testSuccess() {
         parseShort("x").success();
@@ -241,4 +283,36 @@ public void testSuccess() {
     public void testFail() {
         parseShort("12").fail();
     }
+
+    @Test
+    public void testCondition() {
+        final Validation<String, String> one = condition(true, "not 1", "one");
+        assertThat(one.success(), is("one"));
+        final Validation<String, String> fail = condition(false, "not 1", "one");
+        assertThat(fail.fail(), is("not 1"));
+    }
+
+    @Test
+    public void testNel() {
+        assertThat(Validation.success("success").nel().success(), is("success"));
+        assertThat(Validation.fail("fail").nel().fail().head(), is("fail"));
+    }
+
+    @Test
+    public void testFailNEL() {
+        Validation<NonEmptyList<Exception>, Integer> v = failNEL(new Exception("failed"));
+        assertThat(v.isFail(), is(true));
+    }
+
+    @Test
+    public void testEither() {
+        assertThat(either().f(Validation.success("success")).right().value(), is("success"));
+        assertThat(either().f(Validation.fail("fail")).left().value(), is("fail"));
+    }
+
+    @Test
+    public void testValidation() {
+        assertThat(validation().f(Either.right("success")).success(), is("success"));
+        assertThat(validation().f(Either.left("fail")).fail(), is("fail"));
+    }
 }

From 148eab718a81bfd90e5fd8176fb6c4435602da3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sun, 16 Dec 2018 14:12:00 -0500
Subject: [PATCH 233/336] Bring Gradle current
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle                             |   4 ++--
 gradle/wrapper/gradle-wrapper.jar        | Bin 56177 -> 56177 bytes
 gradle/wrapper/gradle-wrapper.properties |   2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index c070903d..37a7b7c3 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,7 +20,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "4.10.2"
+        gradleVersion = "4.10.3"
         distributionType = Wrapper.DistributionType.ALL
     }
 }
@@ -69,7 +69,7 @@ allprojects {
         sonatypeUploadUrl = isSnapshot ? sonatypeSnapshotUrl : sonatypeReleaseUrl
         primaryEmail = "functionaljava@googlegroups.com"
 
-        dependencyJunit = "org.junit.vintage:junit-vintage-engine:5.2.0"
+        dependencyJunit = "org.junit.vintage:junit-vintage-engine:5.3.2"
 
         displayCompilerWarnings = true
     }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 29953ea141f55e3b8fc691d31b5ca8816d89fa87..94336fcae912db8a11d55634156fa011f4686124 100644
GIT binary patch
delta 75
zcmeykjrrp?<_YF3{B|p=CR)d^elGf0#5nPQ^v3PRCxzG;0=(Hd{+{0VNQ{AjK?H~=
bKR6{bS>lv7Sp8=AQ}+Z|K+=;nZ+id$gFGJ;

delta 75
zcmeykjrrp?<_YF3`^8VXPqdC<{aEy|h;iZp>5bcsPYN+H1bDM^WdGhdRg8gwK?H~=
bKR6{bS>lv7Sp8=AQ}+Z|K+=;nZ+id$ib5We

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index d76b502e..ae45383b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

From f85a3698a2b2838c0cc6462c85817a4c06c829d2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Thu, 28 Feb 2019 20:29:08 -0500
Subject: [PATCH 234/336] Bring Gradle to 5.2.1
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle                             |   5 +++--
 consume/build.gradle                     |   3 ++-
 core/build.gradle                        |   3 ++-
 demo/build.gradle                        |   3 ++-
 gradle/wrapper/gradle-wrapper.jar        | Bin 56177 -> 55190 bytes
 gradle/wrapper/gradle-wrapper.properties |   2 +-
 gradlew                                  |   2 +-
 gradlew.bat                              |   2 +-
 java-core/build.gradle                   |   3 ++-
 performance/build.gradle                 |   3 ++-
 props-core-scalacheck/build.gradle       |   3 ++-
 props-core/build.gradle                  |   5 +++--
 quickcheck/build.gradle                  |   2 +-
 13 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/build.gradle b/build.gradle
index 37a7b7c3..b206336a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,7 +20,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "4.10.3"
+        gradleVersion = "5.2.1"
         distributionType = Wrapper.DistributionType.ALL
     }
 }
@@ -69,7 +69,8 @@ allprojects {
         sonatypeUploadUrl = isSnapshot ? sonatypeSnapshotUrl : sonatypeReleaseUrl
         primaryEmail = "functionaljava@googlegroups.com"
 
-        dependencyJunit = "org.junit.vintage:junit-vintage-engine:5.3.2"
+        junitCompile = "junit:junit:4.12"
+        junitRuntime = "org.junit.vintage:junit-vintage-engine:5.3.2"
 
         displayCompilerWarnings = true
     }
diff --git a/consume/build.gradle b/consume/build.gradle
index ff92a601..370ebfbf 100644
--- a/consume/build.gradle
+++ b/consume/build.gradle
@@ -4,5 +4,6 @@ archivesBaseName = "${project.projectName}-${project.name}"
 dependencies {
     compile("$group:$projectName:$fjConsumeVersion")
 
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
diff --git a/core/build.gradle b/core/build.gradle
index 13d06114..767904e0 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -6,7 +6,8 @@ ext {
 archivesBaseName = project.projectName
 
 dependencies {
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
     testCompile 'com.h2database:h2:1.4.197'
     testCompile 'commons-dbutils:commons-dbutils:1.7'
 }
diff --git a/demo/build.gradle b/demo/build.gradle
index e97f94b8..f19e765f 100644
--- a/demo/build.gradle
+++ b/demo/build.gradle
@@ -8,7 +8,8 @@ archivesBaseName = "${project.projectName}-${project.name}"
 dependencies {
     compile project(":core")
     compile project(":quickcheck")
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
 
 test {
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 94336fcae912db8a11d55634156fa011f4686124..87b738cbd051603d91cc39de6cb000dd98fe6b02 100644
GIT binary patch
delta 46897
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

delta 47854
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
aPf3*Jpg@NAy9wFA3{b(qo<LYIu>S`wY|S75

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ae45383b..1b2b07cf 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.10.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index cccdd3d5..af6708ff 100755
--- a/gradlew
+++ b/gradlew
@@ -28,7 +28,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
diff --git a/gradlew.bat b/gradlew.bat
index e95643d6..0f8d5937 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -14,7 +14,7 @@ set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
diff --git a/java-core/build.gradle b/java-core/build.gradle
index 22bf8970..e7b40bb9 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -7,7 +7,8 @@ ext {
 
 dependencies {
     compile project(":core")
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
 
 performSigning(signingEnabled, signModule)
diff --git a/performance/build.gradle b/performance/build.gradle
index cac2f584..c6f4c8a6 100644
--- a/performance/build.gradle
+++ b/performance/build.gradle
@@ -1,5 +1,6 @@
 
 dependencies {
     compile project(":core")
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index 10e494c9..5207bf50 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -15,7 +15,8 @@ dependencies {
     compile "org.scala-lang:scala-library:$scalaVersion"
     compile "org.scalacheck:scalacheck_$scalacheckScalaVersion:$scalacheckVersion"
 
-    testCompile dependencyJunit
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
 
 performSigning(signingEnabled, signModule)
diff --git a/props-core/build.gradle b/props-core/build.gradle
index 181ae5b2..b991bd47 100644
--- a/props-core/build.gradle
+++ b/props-core/build.gradle
@@ -2,6 +2,7 @@
 archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
-	compile project(":quickcheck")
-    testCompile dependencyJunit
+    compile project(":quickcheck")
+    testCompile junitCompile
+    testRuntime junitRuntime
 }
diff --git a/quickcheck/build.gradle b/quickcheck/build.gradle
index b477e26a..2e5dbe4c 100644
--- a/quickcheck/build.gradle
+++ b/quickcheck/build.gradle
@@ -7,7 +7,7 @@ archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
 	compile project(":core")
-    compile dependencyJunit
+    compile junitCompile
 }
 
 performSigning(signingEnabled, signModule)

From c718d06f8320b56084b507b3d5b2d13a6f51ac3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Wed, 13 Mar 2019 18:00:24 -0400
Subject: [PATCH 235/336] Correct Either.iif Javadoc

---
 core/src/main/java/fj/data/Either.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index a9a746a9..dcc950f2 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -898,7 +898,7 @@ public static <A> A reduce(final Either<A, A> e) {
   }
 
   /**
-   * If the condition satisfies, return the given A in left, otherwise, return the given B in right.
+   * If the condition satisfies, return the given B in right, otherwise, return the given A in left.
    *
    * @param c     The condition to test.
    * @param right The right value to use if the condition satisfies.

From 68625ac4f1a40c65b2fb0ad4c24cacbe9288e6bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Fri, 15 Mar 2019 22:17:33 -0400
Subject: [PATCH 236/336] Add Integers tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 .../test/java/fj/function/IntegersTest.java   | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 core/src/test/java/fj/function/IntegersTest.java

diff --git a/core/src/test/java/fj/function/IntegersTest.java b/core/src/test/java/fj/function/IntegersTest.java
new file mode 100644
index 00000000..985afba9
--- /dev/null
+++ b/core/src/test/java/fj/function/IntegersTest.java
@@ -0,0 +1,62 @@
+package fj.function;
+
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import static fj.data.List.list;
+import static fj.data.Option.none;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class IntegersTest {
+
+    @Test
+    public void testSum() {
+        assertThat(Integers.sum(list(3, 4, 5)), is(12));
+    }
+
+    @Test
+    public void testProduct() {
+        assertThat(Integers.product(list(3, 4, 5)), is(60));
+    }
+
+    @Test
+    public void testAdd() {
+        assertThat(Integers.add.f(10).f(20), is(30));
+    }
+
+    @Test
+    public void testMultiply() {
+        assertThat(Integers.multiply.f(3).f(5), is(15));
+    }
+
+    @Test
+    public void testAbs() {
+        assertThat(Integers.abs.f(-5), is(5));
+    }
+
+    @Test
+    public void testFromString() {
+        assertThat(Integers.fromString().f("-123").some(), is(-123));
+    }
+
+    @Test
+    public void testFromStringFail() {
+        assertThat(Integers.fromString().f("w"), is(none()));
+    }
+
+    @Test
+    public void testCannotInstantiate() throws NoSuchMethodException, IllegalAccessException, InstantiationException {
+        Constructor<Integers> constructor = Integers.class.getDeclaredConstructor();
+        constructor.setAccessible(true);
+        try {
+            constructor.newInstance();
+            fail("expected InvocationTargetException");
+        } catch (InvocationTargetException ite) {
+            assertTrue(ite.getCause() instanceof UnsupportedOperationException);
+        }
+    }
+
+}

From d2319f14e9b7b3293532454e110f6f0f675b26db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 6 Apr 2019 15:22:51 -0400
Subject: [PATCH 237/336] Add openjdk12 to Travis
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 .travis.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index bbe5966b..8e7c52c9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,12 +5,13 @@ language: java
 
 jdk:
  - openjdk10
+ - openjdk11
  - openjdk-ea
 
 matrix:
 
   include:
-  - jdk: openjdk11
+  - jdk: openjdk12
     script:
       - ./gradlew build coverage -s -i
     after_success:

From 40ef6c620aade5633e720f0401991bcfd9f18745 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 6 Apr 2019 16:42:41 -0400
Subject: [PATCH 238/336] Add Longs tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 core/src/main/java/fj/function/Longs.java     | 39 ++++++++++++
 core/src/test/java/fj/function/LongsTest.java | 62 +++++++++++++++++++
 2 files changed, 101 insertions(+)
 create mode 100644 core/src/test/java/fj/function/LongsTest.java

diff --git a/core/src/main/java/fj/function/Longs.java b/core/src/main/java/fj/function/Longs.java
index 18667699..0989e8c0 100644
--- a/core/src/main/java/fj/function/Longs.java
+++ b/core/src/main/java/fj/function/Longs.java
@@ -1,11 +1,16 @@
 package fj.function;
 
 import fj.F;
+import fj.Monoid;
+import fj.data.List;
+import fj.data.Option;
 
 import static fj.Function.curry;
 import static fj.Semigroup.longAdditionSemigroup;
 import static fj.Semigroup.longMultiplicationSemigroup;
 
+import static fj.data.Option.none;
+import static fj.data.Option.some;
 import static java.lang.Math.abs;
 
 /**
@@ -48,4 +53,38 @@ private Longs() {
    */
   public static final F<Long, F<Long, Long>> remainder = curry((a, b) -> a % b);
 
+  /**
+   * Sums a list of longs.
+   *
+   * @param longs A list of longs to sum.
+   * @return The sum of the longs in the list.
+   */
+  public static long sum(final List<Long> longs) {
+    return Monoid.longAdditionMonoid.sumLeft(longs);
+  }
+
+  /**
+   * Returns the product of a list of integers.
+   *
+   * @param longs A list of longs to multiply together.
+   * @return The product of the longs in the list.
+   */
+  public static long product(final List<Long> longs) {
+    return Monoid.longMultiplicationMonoid.sumLeft(longs);
+  }
+
+  /**
+   * A function that converts strings to integers.
+   *
+   * @return A function that converts strings to integers.
+   */
+  public static F<String, Option<Long>> fromString() {
+    return s -> {
+      try { return some(Long.valueOf(s)); }
+      catch (final NumberFormatException ignored) {
+        return none();
+      }
+    };
+  }
+
 }
diff --git a/core/src/test/java/fj/function/LongsTest.java b/core/src/test/java/fj/function/LongsTest.java
new file mode 100644
index 00000000..d59fc07c
--- /dev/null
+++ b/core/src/test/java/fj/function/LongsTest.java
@@ -0,0 +1,62 @@
+package fj.function;
+
+import org.junit.Test;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+import static fj.data.List.list;
+import static fj.data.Option.none;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class LongsTest {
+
+    @Test
+    public void testSum() {
+        assertThat(Longs.sum(list(3L, 4L, 5L)), is(12L));
+    }
+
+    @Test
+    public void testProduct() {
+        assertThat(Longs.product(list(3L, 4L, 5L)), is(60L));
+    }
+
+    @Test
+    public void testAdd() {
+        assertThat(Longs.add.f(10L).f(20L), is(30L));
+    }
+
+    @Test
+    public void testMultiply() {
+        assertThat(Longs.multiply.f(3L).f(5L), is(15L));
+    }
+
+    @Test
+    public void testAbs() {
+        assertThat(Longs.abs.f(-5L), is(5L));
+    }
+
+    @Test
+    public void testFromString() {
+        assertThat(Longs.fromString().f("-123").some(), is(-123L));
+    }
+
+    @Test
+    public void testFromStringFail() {
+        assertThat(Longs.fromString().f("w"), is(none()));
+    }
+
+    @Test
+    public void testCannotInstantiate() throws NoSuchMethodException, IllegalAccessException, InstantiationException {
+        Constructor<Longs> constructor = Longs.class.getDeclaredConstructor();
+        constructor.setAccessible(true);
+        try {
+            constructor.newInstance();
+            fail("expected InvocationTargetException");
+        } catch (InvocationTargetException ite) {
+            assertTrue(ite.getCause() instanceof UnsupportedOperationException);
+        }
+    }
+
+}

From 0b8b7f083ce5cac932467e3a839357a568ef6dd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Sat, 12 Oct 2019 13:25:44 -0400
Subject: [PATCH 239/336] Bring Gradle to 5.6.2
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Gábor Lipták <gliptak@gmail.com>
---
 build.gradle                             |   6 +++---
 core/build.gradle                        |   2 +-
 gradle/wrapper/gradle-wrapper.jar        | Bin 55190 -> 55616 bytes
 gradle/wrapper/gradle-wrapper.properties |   2 +-
 gradlew                                  |  22 +++++++++++++++++++---
 gradlew.bat                              |  18 +++++++++++++++++-
 6 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/build.gradle b/build.gradle
index b206336a..69c01425 100644
--- a/build.gradle
+++ b/build.gradle
@@ -20,7 +20,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "5.2.1"
+        gradleVersion = "5.6.2"
         distributionType = Wrapper.DistributionType.ALL
     }
 }
@@ -49,7 +49,7 @@ allprojects {
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.8"
+        fjConsumeVersion = "4.8.1"
 
         signModule = false
 
@@ -70,7 +70,7 @@ allprojects {
         primaryEmail = "functionaljava@googlegroups.com"
 
         junitCompile = "junit:junit:4.12"
-        junitRuntime = "org.junit.vintage:junit-vintage-engine:5.3.2"
+        junitRuntime = "org.junit.vintage:junit-vintage-engine:5.5.2"
 
         displayCompilerWarnings = true
     }
diff --git a/core/build.gradle b/core/build.gradle
index 767904e0..cbdad60b 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -8,7 +8,7 @@ archivesBaseName = project.projectName
 dependencies {
     testCompile junitCompile
     testRuntime junitRuntime
-    testCompile 'com.h2database:h2:1.4.197'
+    testCompile 'com.h2database:h2:1.4.199'
     testCompile 'commons-dbutils:commons-dbutils:1.7'
 }
 
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 87b738cbd051603d91cc39de6cb000dd98fe6b02..5c2d1cf016b3885f6930543d57b744ea8c220a1a 100644
GIT binary patch
delta 3320
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
R^3$e5zsN`FCc2S<;XjD90!#n^

delta 2991
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
Pbkbqm3=F=5f2aQeBaWHL

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 1b2b07cf..ca9d6281 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index af6708ff..83f2acfd 100755
--- a/gradlew
+++ b/gradlew
@@ -1,5 +1,21 @@
 #!/usr/bin/env sh
 
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -28,7 +44,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m"'
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -109,8 +125,8 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
     JAVACMD=`cygpath --unix "$JAVACMD"`
diff --git a/gradlew.bat b/gradlew.bat
index 0f8d5937..24467a14 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -14,7 +30,7 @@ set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m"
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

From ed905700f2dbe8e640ae617a8615a0c5c905e417 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 17:28:54 +0300
Subject: [PATCH 240/336] define base bounded interface

---
 core/src/main/java/fj/Bounded.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 core/src/main/java/fj/Bounded.java

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
new file mode 100644
index 00000000..aea5da25
--- /dev/null
+++ b/core/src/main/java/fj/Bounded.java
@@ -0,0 +1,10 @@
+package fj;
+
+public class Bounded<A> {
+
+    public interface Definition<A> {
+        A min();
+
+        A max();
+    }
+}

From 78b3f7600f102b2cee62e0a3a300b38131fc3b5e Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 17:38:53 +0300
Subject: [PATCH 241/336] implement bounded with factory methods

---
 core/src/main/java/fj/Bounded.java | 32 ++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
index aea5da25..9c64a0b7 100644
--- a/core/src/main/java/fj/Bounded.java
+++ b/core/src/main/java/fj/Bounded.java
@@ -2,9 +2,41 @@
 
 public class Bounded<A> {
 
+    private final Definition<A> def;
+
     public interface Definition<A> {
         A min();
 
         A max();
     }
+
+    private Bounded(Definition<A> definition) {
+        this.def = definition;
+    }
+
+    public A min() {
+        return def.min();
+    }
+
+    public A max() {
+        return def.max();
+    }
+
+    public static <A> Bounded<A> boundedDef(Definition<A> def) {
+        return new Bounded<>(def);
+    }
+
+    public static <A> Bounded<A> bounded(A min, A max) {
+        return boundedDef(new Definition<A>() {
+            @Override
+            public A min() {
+                return min;
+            }
+
+            @Override
+            public A max() {
+                return max;
+            }
+        });
+    }
 }

From 0083c800a32140c7fcdb6dadb793f0cdd07b8dba Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 17:46:40 +0300
Subject: [PATCH 242/336] add bounded for integers

---
 core/src/main/java/fj/Bounded.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
index 9c64a0b7..57827589 100644
--- a/core/src/main/java/fj/Bounded.java
+++ b/core/src/main/java/fj/Bounded.java
@@ -39,4 +39,7 @@ public A max() {
             }
         });
     }
+
+    public static final Bounded<Integer> integerBounded = bounded(Integer.MIN_VALUE, Integer.MAX_VALUE);
+
 }

From 68828d3b8d72c8a481974902090f36b80e12bbd8 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 18:49:01 +0300
Subject: [PATCH 243/336] create tests for set monoid fabric methods

---
 core/src/test/java/fj/MonoidTest.java | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index 8bab5315..99ad5b5e 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -1,6 +1,8 @@
 package fj;
 
+import fj.data.Enumerator;
 import fj.data.Option;
+import fj.data.Set;
 import fj.data.Stream;
 import org.junit.Test;
 
@@ -16,4 +18,26 @@ public void lifted_sum_of_two_numbers() {
     assertThat(optionMonoid.sum(some(3), some(5)), is(some(8)));
     assertThat(optionMonoid.sumLeft(Stream.arrayStream(some(3), some(5))), is(some(8)));
   }
+
+  @Test
+  public void intersection_monoid_test() {
+    Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
+    Monoid<Set<Integer>> intersectionMonoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator, Ord.intOrd);
+    Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+    Set<Integer> zero = intersectionMonoid.zero();
+    Set<Integer> actual = intersectionMonoid.sum(intersectionMonoid.sum(zero, first), second);
+    assertThat(actual, is(Set.set(Ord.intOrd, 3, 4)));
+  }
+
+  @Test
+  public void union_monoid_test() {
+    Monoid<Set<Integer>> intersectionMonoid = Monoid.setMonoid(Ord.intOrd);
+    Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+    Set<Integer> zero = intersectionMonoid.zero();
+    Set<Integer> actual = intersectionMonoid.sum(intersectionMonoid.sum(zero, first), second);
+    assertThat(actual, is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
+  }
+
 }

From 73c31ac71a0605cf36936396f5e3d3646df37abc Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 18:58:16 +0300
Subject: [PATCH 244/336] implement to stream with bounded function in
 enumerator

---
 core/src/main/java/fj/data/Enumerator.java | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index 94f1b2cd..85b8377f 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -1,16 +1,12 @@
 package fj.data;
 
-import fj.F;
+import fj.*;
 
 import static fj.Function.*;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
 
-import fj.Function;
-import fj.Ord;
-
 import static fj.Ord.*;
-import fj.Ordering;
 import static fj.Ordering.*;
 
 import java.math.BigDecimal;
@@ -185,6 +181,18 @@ public Stream<A> toStream(final A a) {
     return Stream.fromFunction(this, id, a);
   }
 
+  /**
+   * Returns a stream of the values from this enumerator,
+   * starting at the min of given Bounded, ending at the max, counting up.
+   *
+   * @param bounded A value at which to begin the stream.
+   * @return a stream of the values from this enumerator, cut by bounded, counting up.
+   */
+  public Stream<A> toStream(final Bounded<A> bounded) {
+    final F<A, A> id = identity();
+    return Stream.fromFunction(this, id, bounded.min()).takeWhile(item -> !item.equals(bounded.max()));
+  }
+
   /**
    * Create a new enumerator with the given minimum value.
    *

From fce0df7b4f6fdc01489536c08da9906d406296ac Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 18:59:38 +0300
Subject: [PATCH 245/336] implement intersection monoid for sets

---
 core/src/main/java/fj/Monoid.java | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 0c09b558..e66a812f 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -2,14 +2,7 @@
 
 import static fj.F1Functions.dimap;
 
-import fj.data.Array;
-import fj.data.DList;
-import fj.data.List;
-import fj.data.IO;
-import fj.data.Natural;
-import fj.data.Option;
-import fj.data.Set;
-import fj.data.Stream;
+import fj.data.*;
 
 import static fj.Function.*;
 import static fj.Semigroup.semigroupDef;
@@ -1109,6 +1102,20 @@ public Set<A> append(Set<A> a1, Set<A> a2) {
     });
   }
 
+  public static <A> Monoid<Set<A>> setIntersectionMonoid(final Bounded<A> bounded, final Enumerator<A> enumerator, final Ord<A> o) {
+    return monoidDef(new Definition<Set<A>>() {
+      @Override
+      public Set<A> empty() {
+        return Set.iteratorSet(o, enumerator.toStream(bounded).iterator());
+      }
+
+      @Override
+      public Set<A> append(Set<A> a1, Set<A> a2) {
+        return a1.intersect(a2);
+      }
+    });
+  }
+
   /**
    * A monoid for the maximum of elements with ordering o.
    * @deprecated since 4.7. Use {@link Ord#maxMonoid(Object)}

From b550ca45e4bed28153bac587201ac570118df638 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 19:05:28 +0300
Subject: [PATCH 246/336] fix set monoid method docs

---
 core/src/main/java/fj/Monoid.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index e66a812f..02bba94a 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -1083,7 +1083,7 @@ public Unit append(Unit a1, Unit a2) {
   });
 
   /**
-   * A monoid for sets.
+   * A union monoid for sets.
    *
    * @param o An order for set elements.
    * @return A monoid for sets whose elements have the given order.

From 3c4e35fb9cb32ab3584cdf49fde27fe7d8987049 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 19:05:49 +0300
Subject: [PATCH 247/336] add docs for intersection set monoid

---
 core/src/main/java/fj/Monoid.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 02bba94a..2b3400c0 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -1102,6 +1102,14 @@ public Set<A> append(Set<A> a1, Set<A> a2) {
     });
   }
 
+  /**
+   * A intersection monoid for sets.
+   *
+   * @param bounded A bound for all possible elements
+   * @param enumerator An enumerator for all possible elements
+   * @param o An order for set elements.
+   * @return A monoid for sets whose elements have the given order.
+   */
   public static <A> Monoid<Set<A>> setIntersectionMonoid(final Bounded<A> bounded, final Enumerator<A> enumerator, final Ord<A> o) {
     return monoidDef(new Definition<Set<A>>() {
       @Override

From b602a2c2c598615b7ceb305d6ca79253449a36e5 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 19:50:53 +0300
Subject: [PATCH 248/336] add docs for bounded

---
 core/src/main/java/fj/Bounded.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
index 57827589..22d59ef5 100644
--- a/core/src/main/java/fj/Bounded.java
+++ b/core/src/main/java/fj/Bounded.java
@@ -1,9 +1,16 @@
 package fj;
 
+/**
+ * The Bounded class is used to name the upper and lower limits of a type.
+ * Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.
+ */
 public class Bounded<A> {
 
     private final Definition<A> def;
 
+    /**
+     * Minimal definition of Bounded
+     */
     public interface Definition<A> {
         A min();
 

From ea6fcc7127219874ba550005d3de20ea76d789b3 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 19:51:11 +0300
Subject: [PATCH 249/336] remove integer bounded implementation

---
 core/src/main/java/fj/Bounded.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
index 22d59ef5..980ba9a3 100644
--- a/core/src/main/java/fj/Bounded.java
+++ b/core/src/main/java/fj/Bounded.java
@@ -47,6 +47,4 @@ public A max() {
         });
     }
 
-    public static final Bounded<Integer> integerBounded = bounded(Integer.MIN_VALUE, Integer.MAX_VALUE);
-
 }

From 4b25bf8797258361c8ce0624a1f9f4a2721e3384 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 20:01:36 +0300
Subject: [PATCH 250/336] rename monoid variable in union monoid test

---
 core/src/test/java/fj/MonoidTest.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index 99ad5b5e..35e71c28 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -32,11 +32,11 @@ public void intersection_monoid_test() {
 
   @Test
   public void union_monoid_test() {
-    Monoid<Set<Integer>> intersectionMonoid = Monoid.setMonoid(Ord.intOrd);
+    Monoid<Set<Integer>> unionMonoid = Monoid.setMonoid(Ord.intOrd);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
     Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
-    Set<Integer> zero = intersectionMonoid.zero();
-    Set<Integer> actual = intersectionMonoid.sum(intersectionMonoid.sum(zero, first), second);
+    Set<Integer> zero = unionMonoid.zero();
+    Set<Integer> actual = unionMonoid.sum(unionMonoid.sum(zero, first), second);
     assertThat(actual, is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
   }
 

From 606f1e72803937b578e03aaca3f2c4dfd99c7c4c Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 20:01:59 +0300
Subject: [PATCH 251/336] add tests for set semigroup

---
 core/src/test/java/fj/SemigroupTest.java | 26 ++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 core/src/test/java/fj/SemigroupTest.java

diff --git a/core/src/test/java/fj/SemigroupTest.java b/core/src/test/java/fj/SemigroupTest.java
new file mode 100644
index 00000000..20ecb2cb
--- /dev/null
+++ b/core/src/test/java/fj/SemigroupTest.java
@@ -0,0 +1,26 @@
+package fj;
+
+import fj.data.Set;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class SemigroupTest {
+
+    @Test
+    public void intersection_semigroup_test() {
+        Semigroup<Set<Integer>> intersectionSemigroup = Semigroup.setIntersectionSemigroup();
+        Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+        Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+        assertThat(intersectionSemigroup.sum(first, second), is(Set.set(Ord.intOrd, 3, 4)));
+    }
+
+    @Test
+    public void union_semigroup_test() {
+        Semigroup<Set<Integer>> unionSemigroup = Semigroup.setSemigroup();
+        Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
+        Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
+        assertThat(unionSemigroup.sum(first, second), is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
+    }
+}

From b710672ec4586752c6d3265e3c8b80994d860ff1 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 20 Oct 2019 20:02:16 +0300
Subject: [PATCH 252/336] implement intersection semigroup

---
 core/src/main/java/fj/Semigroup.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 42f05f5b..c512e383 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -629,4 +629,8 @@ public static <A> Semigroup<Set<A>> setSemigroup() {
     return semigroupDef(Set::union);
   }
 
+  public static <A> Semigroup<Set<A>> setIntersectionSemigroup() {
+    return semigroupDef(Set::intersect);
+  }
+
 }

From a6a0d21d6accc1e3b7b19f142e1f492b40845f1c Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Mon, 21 Oct 2019 19:25:49 +0300
Subject: [PATCH 253/336] add tests for zero elements of monoids

---
 core/src/test/java/fj/MonoidTest.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index 35e71c28..721903b4 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -40,4 +40,21 @@ public void union_monoid_test() {
     assertThat(actual, is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
   }
 
+  @Test
+  public void intersection_monoid_zero_test() {
+    Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
+    Monoid<Set<Integer>> monoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator, Ord.intOrd);
+    Set<Integer> set = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> zero = monoid.zero();
+    assertThat(monoid.sum(zero, set), is(set));
+  }
+
+  @Test
+  public void union_monoid_zero_test() {
+    Monoid<Set<Integer>> monoid = Monoid.setMonoid(Ord.intOrd);
+    Set<Integer> set = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> zero = monoid.zero();
+    assertThat(monoid.sum(zero, set), is(set));
+  }
+
 }

From 226c84a74316d7d425610899eed2d0ef22d49599 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Mon, 21 Oct 2019 19:27:41 +0300
Subject: [PATCH 254/336] remove zero from monoids tests

---
 core/src/test/java/fj/MonoidTest.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index 721903b4..d61da72f 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -25,8 +25,7 @@ public void intersection_monoid_test() {
     Monoid<Set<Integer>> intersectionMonoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator, Ord.intOrd);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
     Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
-    Set<Integer> zero = intersectionMonoid.zero();
-    Set<Integer> actual = intersectionMonoid.sum(intersectionMonoid.sum(zero, first), second);
+    Set<Integer> actual = intersectionMonoid.sum(first, second);
     assertThat(actual, is(Set.set(Ord.intOrd, 3, 4)));
   }
 
@@ -35,8 +34,7 @@ public void union_monoid_test() {
     Monoid<Set<Integer>> unionMonoid = Monoid.setMonoid(Ord.intOrd);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
     Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
-    Set<Integer> zero = unionMonoid.zero();
-    Set<Integer> actual = unionMonoid.sum(unionMonoid.sum(zero, first), second);
+    Set<Integer> actual = unionMonoid.sum(first, second);
     assertThat(actual, is(Set.set(Ord.intOrd, 1, 2, 3, 4, 5, 6)));
   }
 

From 1a40c67f5502980a1c18fa4e54bc56a0ad9d8362 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Mon, 21 Oct 2019 19:29:31 +0300
Subject: [PATCH 255/336] add docs for semigroups

---
 core/src/main/java/fj/Semigroup.java | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index c512e383..ef8029b3 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -621,7 +621,7 @@ public static <A> Semigroup<IO<A>> ioSemigroup(final Semigroup <A> sa) {
   public static final Semigroup<Unit> unitSemigroup = unitMonoid.semigroup();
 
   /**
-   * A semigroup for sets.
+   * A union semigroup for sets.
    *
    * @return a semigroup for sets.
    */
@@ -629,6 +629,11 @@ public static <A> Semigroup<Set<A>> setSemigroup() {
     return semigroupDef(Set::union);
   }
 
+  /**
+   * A intersection semigroup for sets.
+   *
+   * @return a semigroup for sets.
+   */
   public static <A> Semigroup<Set<A>> setIntersectionSemigroup() {
     return semigroupDef(Set::intersect);
   }

From 854d1958fffa8dedc56db0a2a2650f591949d983 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gr=C3=A9goire=20Neuville?=
 <gregoire.neuville@univ-rennes1.fr>
Date: Mon, 28 Oct 2019 17:44:16 +0100
Subject: [PATCH 256/336] Basic JPMS (modules) support through
 'Automatic-Module-Name'

---
 build.gradle | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build.gradle b/build.gradle
index 67d8cd15..91bd5433 100644
--- a/build.gradle
+++ b/build.gradle
@@ -181,6 +181,7 @@ configure(subprojects.findAll { it.name != "props-core" }) {
         buildCommand 'org.eclipse.pde.ManifestBuilder'
         buildCommand 'org.eclipse.pde.SchemaBuilder'
       }
+      instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : "-$project.name"}"
     }
 
     // Output MANIFEST.MF statically so eclipse can see it for plugin development

From 1fed6abe362ee3a3931b11947570dd76baad9986 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gr=C3=A9goire=20Neuville?=
 <gregoire.neuville@univ-rennes1.fr>
Date: Tue, 29 Oct 2019 12:10:05 +0100
Subject: [PATCH 257/336] Fix previous commit

---
 build.gradle | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/build.gradle b/build.gradle
index 91bd5433..2ac9a9c0 100644
--- a/build.gradle
+++ b/build.gradle
@@ -169,9 +169,10 @@ configure(subprojects.findAll { it.name != "props-core" }) {
             instruction 'Signature-Version', project.fjVersion
             instruction 'Bundle-ActivationPolicy', 'lazy'
             instruction 'Bundle-Vendor', 'functionaljava.org'
-			if(project.name != "core") {
-				instruction 'Require-Bundle', 'org.functionaljava;bundle-version="'+project.fjBaseVersion+'"'
-			}
+            if(project.name != "core") {
+                instruction 'Require-Bundle', 'org.functionaljava;bundle-version="'+project.fjBaseVersion+'"'
+            }
+            instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : "-$project.name"}"
         }
     }
 
@@ -181,7 +182,6 @@ configure(subprojects.findAll { it.name != "props-core" }) {
         buildCommand 'org.eclipse.pde.ManifestBuilder'
         buildCommand 'org.eclipse.pde.SchemaBuilder'
       }
-      instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : "-$project.name"}"
     }
 
     // Output MANIFEST.MF statically so eclipse can see it for plugin development

From 57699342be52381724ac34cf2b867cbd1d4ff407 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gr=C3=A9goire=20Neuville?=
 <gregoire.neuville@univ-rennes1.fr>
Date: Tue, 29 Oct 2019 12:29:34 +0100
Subject: [PATCH 258/336] Dash character isn't allowed in modules names

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 2ac9a9c0..c9d8be40 100644
--- a/build.gradle
+++ b/build.gradle
@@ -172,7 +172,7 @@ configure(subprojects.findAll { it.name != "props-core" }) {
             if(project.name != "core") {
                 instruction 'Require-Bundle', 'org.functionaljava;bundle-version="'+project.fjBaseVersion+'"'
             }
-            instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : "-$project.name"}"
+            instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : ".$project.name"}"
         }
     }
 

From 6cadc81f9b651b90cfb3e2d79c99a3b70caddbe8 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 3 Nov 2019 15:58:10 +0300
Subject: [PATCH 259/336] remove ord parameter and provide it from enumerator

---
 core/src/main/java/fj/Monoid.java     | 5 ++---
 core/src/test/java/fj/MonoidTest.java | 4 ++--
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 2b3400c0..490dc9d6 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -1107,14 +1107,13 @@ public Set<A> append(Set<A> a1, Set<A> a2) {
    *
    * @param bounded A bound for all possible elements
    * @param enumerator An enumerator for all possible elements
-   * @param o An order for set elements.
    * @return A monoid for sets whose elements have the given order.
    */
-  public static <A> Monoid<Set<A>> setIntersectionMonoid(final Bounded<A> bounded, final Enumerator<A> enumerator, final Ord<A> o) {
+  public static <A> Monoid<Set<A>> setIntersectionMonoid(final Bounded<A> bounded, final Enumerator<A> enumerator) {
     return monoidDef(new Definition<Set<A>>() {
       @Override
       public Set<A> empty() {
-        return Set.iteratorSet(o, enumerator.toStream(bounded).iterator());
+        return Set.iteratorSet(enumerator.order(), enumerator.toStream(bounded).iterator());
       }
 
       @Override
diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index d61da72f..f185a124 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -22,7 +22,7 @@ public void lifted_sum_of_two_numbers() {
   @Test
   public void intersection_monoid_test() {
     Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
-    Monoid<Set<Integer>> intersectionMonoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator, Ord.intOrd);
+    Monoid<Set<Integer>> intersectionMonoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
     Set<Integer> second = Set.set(Ord.intOrd, 3, 4, 5, 6);
     Set<Integer> actual = intersectionMonoid.sum(first, second);
@@ -41,7 +41,7 @@ public void union_monoid_test() {
   @Test
   public void intersection_monoid_zero_test() {
     Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
-    Monoid<Set<Integer>> monoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator, Ord.intOrd);
+    Monoid<Set<Integer>> monoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator);
     Set<Integer> set = Set.set(Ord.intOrd, 1, 2, 3, 4);
     Set<Integer> zero = monoid.zero();
     assertThat(monoid.sum(zero, set), is(set));

From fe19604e96855faaa6005aeda6b71c24bcb66a53 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 3 Nov 2019 16:03:31 +0300
Subject: [PATCH 260/336] fix missing max value of bounded

---
 core/src/main/java/fj/data/Enumerator.java | 2 +-
 core/src/test/java/fj/MonoidTest.java      | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/Enumerator.java b/core/src/main/java/fj/data/Enumerator.java
index 85b8377f..2fa96a6f 100644
--- a/core/src/main/java/fj/data/Enumerator.java
+++ b/core/src/main/java/fj/data/Enumerator.java
@@ -190,7 +190,7 @@ public Stream<A> toStream(final A a) {
    */
   public Stream<A> toStream(final Bounded<A> bounded) {
     final F<A, A> id = identity();
-    return Stream.fromFunction(this, id, bounded.min()).takeWhile(item -> !item.equals(bounded.max()));
+    return Stream.fromFunction(this, id, bounded.min()).takeWhile(item -> order.isLessThanOrEqualTo(item, bounded.max()));
   }
 
   /**
diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index f185a124..a54bf672 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -29,7 +29,7 @@ public void intersection_monoid_test() {
     assertThat(actual, is(Set.set(Ord.intOrd, 3, 4)));
   }
 
-  @Test
+    @Test
   public void union_monoid_test() {
     Monoid<Set<Integer>> unionMonoid = Monoid.setMonoid(Ord.intOrd);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);
@@ -42,7 +42,7 @@ public void union_monoid_test() {
   public void intersection_monoid_zero_test() {
     Bounded<Integer> integersBounded = Bounded.bounded(0, 10);
     Monoid<Set<Integer>> monoid = Monoid.setIntersectionMonoid(integersBounded, Enumerator.intEnumerator);
-    Set<Integer> set = Set.set(Ord.intOrd, 1, 2, 3, 4);
+    Set<Integer> set = Set.set(Ord.intOrd, 7, 8, 9, 10);
     Set<Integer> zero = monoid.zero();
     assertThat(monoid.sum(zero, set), is(set));
   }

From 5b6fafccb10c433f52dbcc0aff375e0aef89aaa3 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 3 Nov 2019 16:04:52 +0300
Subject: [PATCH 261/336] make bounded class final

---
 core/src/main/java/fj/Bounded.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Bounded.java b/core/src/main/java/fj/Bounded.java
index 980ba9a3..e100b6d6 100644
--- a/core/src/main/java/fj/Bounded.java
+++ b/core/src/main/java/fj/Bounded.java
@@ -4,7 +4,7 @@
  * The Bounded class is used to name the upper and lower limits of a type.
  * Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.
  */
-public class Bounded<A> {
+public final class Bounded<A> {
 
     private final Definition<A> def;
 

From dc9e0a9de8b897cd3ff53bf5c154494786b9dd98 Mon Sep 17 00:00:00 2001
From: Yaroslav Atroshenko <yaaroslavok@gmail.com>
Date: Sun, 3 Nov 2019 16:10:18 +0300
Subject: [PATCH 262/336] code clean up

---
 core/src/test/java/fj/MonoidTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index a54bf672..1156e729 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -29,7 +29,7 @@ public void intersection_monoid_test() {
     assertThat(actual, is(Set.set(Ord.intOrd, 3, 4)));
   }
 
-    @Test
+  @Test
   public void union_monoid_test() {
     Monoid<Set<Integer>> unionMonoid = Monoid.setMonoid(Ord.intOrd);
     Set<Integer> first = Set.set(Ord.intOrd, 1, 2, 3, 4);

From ac4819d9a71dd82f888db4663f47ab3e39c80cd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?G=C3=A1bor=20Lipt=C3=A1k?= <gliptak@gmail.com>
Date: Fri, 13 Dec 2019 09:11:52 -0500
Subject: [PATCH 263/336] Switch to gradle-versions-plugin

---
 build.gradle | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/build.gradle b/build.gradle
index 69c01425..5fbad7bc 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,14 +1,9 @@
 
 defaultTasks 'build'
 
-ext {
-}
+apply plugin: "com.github.ben-manes.versions"
 
 buildscript {
-    ext {
-        uptodateVersion = "1.6.3"
-    }
-
     repositories {
         mavenLocal()
         jcenter()
@@ -16,7 +11,7 @@ buildscript {
     }
 
     dependencies {
-        classpath "com.ofg:uptodate-gradle-plugin:$uptodateVersion"
+        classpath "com.github.ben-manes:gradle-versions-plugin:0.27.0"
     }
 
     wrapper {
@@ -98,7 +93,6 @@ subprojects {
     apply from: "$rootDir/lib.gradle"
 	apply plugin: "java"
 	apply plugin: "eclipse"
-    apply plugin: "com.ofg.uptodate"
 
 	repositories {
         mavenLocal()

From 560db2e6d9deaf2bb24bea21d65ab7c410977bce Mon Sep 17 00:00:00 2001
From: Drew Taylor <drewctaylor@gmail.com>
Date: Tue, 19 May 2020 20:29:26 -0400
Subject: [PATCH 264/336] Add fj.test.Gen.streamOf(Gen<A>), similar to
 fj.test.Gen.listOf(Gen<A>, int); returns a generator of streams whose values
 come from the given generator.

---
 quickcheck/src/main/java/fj/test/Gen.java     | 13 +++++++++++++
 quickcheck/src/test/java/fj/test/GenTest.java | 16 ++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index c375874d..527d620c 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -9,6 +9,7 @@
 import fj.data.Array;
 import fj.data.List;
 import fj.data.Option;
+import fj.data.Stream;
 import fj.function.Effect1;
 
 import static fj.Bottom.error;
@@ -497,6 +498,18 @@ public static <A> Gen<List<A>> listOf1(final Gen<A> g) {
     return listOf(g, 1);
   }
 
+  /**
+   * Returns a generator of streams whose values come from the given generator.
+   *
+   * @param g   the generator to produce values from for the returned generator
+   * @param <A> the type of the generator
+   *
+   * @return A generator of streams whose values come from the given generator.
+   */
+  public static <A> Gen<Stream<A>> streamOf(final Gen<A> g) {
+    return gen(i -> r -> Stream.cons(g.gen(i, r), () -> streamOf(g).gen(i, r)));
+  }
+
   /**
    * Returns a generator that picks one element from the given list. If the given list is empty, then the
    * returned generator will never produce a value.
diff --git a/quickcheck/src/test/java/fj/test/GenTest.java b/quickcheck/src/test/java/fj/test/GenTest.java
index 900369a7..9ec0ec79 100644
--- a/quickcheck/src/test/java/fj/test/GenTest.java
+++ b/quickcheck/src/test/java/fj/test/GenTest.java
@@ -1,16 +1,19 @@
 package fj.test;
 
 import fj.data.List;
+import fj.data.Stream;
 import fj.function.Effect1;
 import org.junit.Test;
 
 import static fj.Ord.charOrd;
 import static fj.data.List.list;
 import static fj.data.List.range;
-import static fj.test.Gen.selectionOf;
 import static fj.test.Gen.combinationOf;
-import static fj.test.Gen.wordOf;
 import static fj.test.Gen.permutationOf;
+import static fj.test.Gen.pickOne;
+import static fj.test.Gen.selectionOf;
+import static fj.test.Gen.streamOf;
+import static fj.test.Gen.wordOf;
 import static fj.test.Rand.standard;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
@@ -175,6 +178,15 @@ public void testWordOf_four() {
     });
   }
 
+  @Test
+  public void testStreamOf() {
+    final Gen<Stream<Character>> instance = streamOf(pickOne(AS));
+    testPick(100, instance.map(stream -> stream.take(4).toList()), actual -> {
+      assertEquals(4, actual.length());
+      assertTrue(actual.forall(actualA -> AS.exists(a -> a.equals(actualA))));
+    });
+  }
+
   private static <A> void testPick(int n, Gen<List<A>> instance, Effect1<List<A>> test) {
     range(0, n).map(ignore -> instance.gen(0, standard)).foreachDoEffect(test);
   }

From e98db344df3023beb0898688a682fe73e2c134ec Mon Sep 17 00:00:00 2001
From: Drew Taylor <drewctaylor@gmail.com>
Date: Wed, 20 May 2020 19:16:19 -0400
Subject: [PATCH 265/336] Add fj.data.Option.sequence(Validation<E,
 Option<A>>).

---
 core/src/main/java/fj/data/Option.java     | 16 +++++++++++---
 core/src/test/java/fj/data/OptionTest.java | 25 +++++++++++++++++++++-
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 54b4bb01..1a170c2c 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -372,11 +372,11 @@ public final <B> Option<P2<A,B>> bindProduct(final Option<B> ob) {
   public final <B, C> Option<P3<A,B,C>> bindProduct(final Option<B> ob, final Option<C> oc) {
     return bind(ob, oc, P.p3());
   }
-  
+
   public final <B, C, D> Option<P4<A,B,C,D>> bindProduct(final Option<B> ob, final Option<C> oc, final Option<D> od) {
     return bind(ob, oc, od, P.p4());
   }
-  
+
   public final <B,C,D,E> Option<P5<A,B,C,D,E>> bindProduct(final Option<B> ob, final Option<C> oc, final Option<D> od,
                                                      final Option<E> oe) {
     return bind(ob, oc, od, oe, P.p5());
@@ -712,7 +712,7 @@ public static <A> Option<A> join(final Option<Option<A>> o) {
   }
 
   /**
-   * Sequence through the option monad.
+   * Sequence a list through the option monad.
    *
    * @param a The list of option to sequence.
    * @return The option of list after sequencing.
@@ -723,6 +723,16 @@ public static <A> Option<List<A>> sequence(final List<Option<A>> a) {
            a.head().bind(aa -> sequence(a.tail()).map(cons_(aa)));
   }
 
+  /**
+   * Sequence a validation through the option monad.
+   *
+   * @param a The validation of option to sequence.
+   * @return The option of validation after sequencing.
+   */
+  public static <E, A> Option<Validation<E, A>> sequence(final Validation<E, Option<A>> a) {
+    return a.traverseOption(identity());
+  }
+
   /**
    * Returns an optional value that has a value of the given argument, if the given predicate holds
    * on that argument, otherwise, returns no value.
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index 3eeed489..0966ece0 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -1,9 +1,15 @@
 package fj.data;
 
-import org.junit.Assert;
 import org.junit.Test;
 
+import static fj.data.List.arrayList;
+import static fj.data.List.nil;
+import static fj.data.Option.none;
+import static fj.data.Option.sequence;
 import static fj.data.Option.some;
+import static fj.data.Validation.fail;
+import static fj.data.Validation.success;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
 /**
@@ -26,4 +32,21 @@ public void traverseList() {
         assertTrue(actual.equals(expected));
     }
 
+    @Test
+    public void sequenceListTest() {
+        assertEquals(some(nil()), sequence(nil()));
+        assertEquals(none(), sequence(arrayList(none())));
+        assertEquals(some(arrayList(1)), sequence(arrayList(some(1))));
+        assertEquals(none(), sequence(arrayList(none(), none())));
+        assertEquals(none(), sequence(arrayList(some(1), none())));
+        assertEquals(none(), sequence(arrayList(none(), some(2))));
+        assertEquals(some(arrayList(1, 2)), sequence(arrayList(some(1), some(2))));
+    }
+
+    @Test
+    public void sequenceValidationTest() {
+        assertEquals(some(fail(1)), sequence(Validation.<Integer, Option<String>>fail(1)));
+        assertEquals(none(), sequence(Validation.<Integer, Option<String>>success(none())));
+        assertEquals(some(success("string")), sequence(Validation.<Integer, Option<String>>success(some("string"))));
+    }
 }

From 0a50e8b02c8dd00f7039d40f10eeefc10bfb3547 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Mon, 20 Jul 2020 21:55:04 -0400
Subject: [PATCH 266/336] Fixes #401. Add fj.test.Gen.sequence(Validation<E,
 Gen<A>>).

---
 quickcheck/src/main/java/fj/test/Gen.java     | 14 ++++++++++++++
 quickcheck/src/test/java/fj/test/GenTest.java | 19 +++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index 527d620c..dabaf9a6 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -10,6 +10,7 @@
 import fj.data.List;
 import fj.data.Option;
 import fj.data.Stream;
+import fj.data.Validation;
 import fj.function.Effect1;
 
 import static fj.Bottom.error;
@@ -319,6 +320,19 @@ public static <A> Gen<List<A>> sequenceN(final int n, final Gen<A> g) {
     return sequence(replicate(n, g));
   }
 
+  /**
+   * Transform a validation for a generator into a generator of validations: if the given validation is a failure, the
+   * generator produces that failure value; if the given validation is a success, the generator produces success values.
+   *
+   * @param gv  The validation for a generator.
+   * @param <A> the type of the value
+   * @param <E> the type of the failure
+   * @return if the given validation is a failure, the generator produces that failure value; if the given validation is a success, the generator produces success values.
+   */
+  public static <E, A> Gen<Validation<E, A>> sequence(final Validation<E, Gen<A>> gv) {
+    return gen(i -> r -> gv.map(g -> g.gen(i, r)));
+  }
+
   /**
    * Constructs a generator that can access its construction arguments &mdash; size and random
    * generator.
diff --git a/quickcheck/src/test/java/fj/test/GenTest.java b/quickcheck/src/test/java/fj/test/GenTest.java
index 9ec0ec79..c13480a1 100644
--- a/quickcheck/src/test/java/fj/test/GenTest.java
+++ b/quickcheck/src/test/java/fj/test/GenTest.java
@@ -1,17 +1,27 @@
 package fj.test;
 
+import fj.Equal;
 import fj.data.List;
+import fj.data.NonEmptyList;
+import fj.data.Option;
 import fj.data.Stream;
+import fj.data.Validation;
 import fj.function.Effect1;
 import org.junit.Test;
 
 import static fj.Ord.charOrd;
 import static fj.data.List.list;
 import static fj.data.List.range;
+import static fj.data.NonEmptyList.nel;
+import static fj.data.Option.somes;
+import static fj.data.Validation.fail;
+import static fj.data.Validation.success;
 import static fj.test.Gen.combinationOf;
+import static fj.test.Gen.listOf;
 import static fj.test.Gen.permutationOf;
 import static fj.test.Gen.pickOne;
 import static fj.test.Gen.selectionOf;
+import static fj.test.Gen.sequence;
 import static fj.test.Gen.streamOf;
 import static fj.test.Gen.wordOf;
 import static fj.test.Rand.standard;
@@ -187,6 +197,15 @@ public void testStreamOf() {
     });
   }
 
+  @Test
+  public void testSequenceValidation() {
+    final Gen<List<Validation<NonEmptyList<Exception>, Character>>> success = listOf(sequence(success(pickOne(AS))), 4);
+    testPick(100, success, list -> assertEquals(list.length(),somes(list.map(v -> Option.sequence(v.map(c -> AS.elementIndex(Equal.anyEqual(), c))))).length()));
+
+    final Gen<List<Validation<NonEmptyList<Exception>, Gen<Character>>>> failure = listOf(sequence(fail(nel(new Exception()))), 4);
+    testPick(100, failure, list -> assertTrue(list.forall(a -> a.isFail())));
+  }
+
   private static <A> void testPick(int n, Gen<List<A>> instance, Effect1<List<A>> test) {
     range(0, n).map(ignore -> instance.gen(0, standard)).foreachDoEffect(test);
   }

From b8c309374065364ae5922244795efbe8e40adffe Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Thu, 23 Jul 2020 13:42:30 -0400
Subject: [PATCH 267/336] Fixes #403. Add fj.data.Validation.sequence*,
 fj.data.Validation.traverse*.

---
 core/src/main/java/fj/data/Validation.java    | 358 ++++++++++++++++--
 .../src/test/java/fj/data/ValidationTest.java | 209 ++++++++++
 2 files changed, 530 insertions(+), 37 deletions(-)
 create mode 100644 core/src/test/java/fj/data/ValidationTest.java

diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 58aa5e9c..2afb91f3 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -1,17 +1,18 @@
 package fj.data;
 
 import fj.*;
+import fj.control.Trampoline;
 import fj.function.Effect1;
 
-import static fj.Function.curry;
-import static fj.P.p;
+import java.util.Iterator;
 
-import static fj.Unit.unit;
 import static fj.Bottom.error;
+import static fj.Function.*;
+import static fj.P.p;
+import static fj.Unit.unit;
+import static fj.data.Either.*;
 import static fj.data.List.list;
 
-import java.util.Iterator;
-
 /**
  * Isomorphic to {@link Either} but has renamed functions and represents failure on the left and success on the right.
  * This type also has accumulating functions that accept a {@link Semigroup} for binding computation while keeping error
@@ -825,44 +826,327 @@ public static <A, E> Validation<List<E>, List<A>> sequenceNonCumulative(List<Val
       }
     }
 
-    public final <C> List<Validation<E, C>> traverseList(F<T, List<C>> f){
-        return isSuccess() ?
-            f.f(success()).map(Validation::success) :
-            List.iterableList(fail(e.left().value()));
-    }
+  /**
+   * Sequence the given validation and collect the output on the left side of an either.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <R>        the type of the right value
+   * @param <C>        the type of the left value
+   * @return the either
+   */
+  public static final <E, R, C> Either<Validation<E, C>, R> sequenceEitherLeft(final Validation<E, Either<C, R>> validation) {
+    return validation.traverseEitherLeft(identity());
+  }
 
-    public final <C> Stream<Validation<E, C>> traverseStream(F<T, Stream<C>> f){
-        return isSuccess() ?
-            f.f(success()).map(Validation::success) :
-            Stream.iterableStream(fail(e.left().value()));
-    }
+  /**
+   * Sequence the given validation and collect the output on the right side of an either.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the right value
+   * @param <L>        the type of the left value
+   * @return the either
+   */
+  public static final <E, L, C> Either<L, Validation<E, C>> sequenceEitherRight(final Validation<E, Either<L, C>> validation) {
+    return validation.traverseEitherRight(identity());
+  }
 
-    public final <C> Option<Validation<E, C>> traverseOption(F<T, Option<C>> f){
-        return isSuccess() ?
-            f.f(success()).map(Validation::success) :
-            Option.some(fail(e.left().value()));
-    }
+  /**
+   * Sequence the given validation and collect the output as a function.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of input value
+   * @param <B>        the type of output value
+   * @return the function
+   */
+  public static final <E, C, B> F<C, Validation<E, B>> sequenceF(final Validation<E, F<C, B>> validation) {
+    return validation.traverseF(identity());
+  }
 
-    public final <C> IO<Validation<E, C>> traverseIO(F<T, IO<C>> f){
-        return isSuccess() ?
-            IOFunctions.map(f.f(success()), Validation::success) :
-            IOFunctions.unit(fail(e.left().value()));
-    }
+  /**
+   * Sequence the given validation and collect the output as an IO.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the IO value
+   * @return the IO
+   */
+  public static final <E, C> IO<Validation<E, C>> sequenceIO(final Validation<E, IO<C>> validation) {
+    return validation.traverseIO(identity());
+  }
 
-    public final <C> P1<Validation<E, C>> traverseP1(F<T, P1<C>> f){
-        return isSuccess() ?
-                f.f(success()).map(Validation::success) :
-                p(fail(e.left().value()));
-    }
+  /**
+   * Sequence the given validation and collect the output as a list.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the list value
+   * @return the list
+   */
+  public static final <E, C> List<Validation<E, C>> sequenceList(final Validation<E, List<C>> validation) {
+    return validation.traverseList(identity());
+  }
+
+  /**
+   * Sequence the given validation and collect the output as an option.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the option value
+   * @return the option
+   */
+  public static final <E, C> Option<Validation<E, C>> sequenceOption(final Validation<E, Option<C>> validation) {
+    return validation.traverseOption(identity());
+  }
 
+  /**
+   * Sequence the given validation and collect the output as a P1.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the P1 value
+   * @return the P1
+   */
+  public static final <E, C> P1<Validation<E, C>> sequenceP1(final Validation<E, P1<C>> validation) {
+    return validation.traverseP1(identity());
+  }
 
-    public static <A, E> List<E> fails(List<Validation<E, ?>> list) {
-        return list.filter(Validation::isFail).map(v -> v.fail());
-    }
+  /**
+   * Sequence the given validation and collect the output as a seq.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the seq value
+   * @return the seq
+   */
+  public static final <E, C> Seq<Validation<E, C>> sequenceSeq(final Validation<E, Seq<C>> validation) {
+    return validation.traverseSeq(identity());
+  }
 
-    public static <A, E> List<A> successes(List<Validation<?, A>> list) {
-        return list.filter(Validation::isSuccess).map(v -> v.success());
-    }
+  /**
+   * Sequence the given validation and collect the output as a set.
+   *
+   * @param ordE       the given failure value ord
+   * @param ordC       the given success value ord
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the set value
+   * @return the set
+   */
+  public static final <E, C> Set<Validation<E, C>> sequenceSet(final Ord<E> ordE, final Ord<C> ordC, final Validation<E, Set<C>> validation) {
+    return validation.traverseSet(ordE, ordC, identity());
+  }
+
+  /**
+   * Sequence the given validation and collect the output as a stream.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the stream value
+   * @return the stream
+   */
+  public static final <E, C> Stream<Validation<E, C>> sequenceStream(final Validation<E, Stream<C>> validation) {
+    return validation.traverseStream(identity());
+  }
+
+  /**
+   * Sequence the given validation and collect the output as a trampoline.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <C>        the type of the trampoline value
+   * @return the trampoline
+   */
+  public static final <E, C> Trampoline<Validation<E, C>> sequenceTrampoline(final Validation<E, Trampoline<C>> validation) {
+    return validation.traverseTrampoline(identity());
+  }
+
+  /**
+   * Sequence the given validation and collect the output as a validation.
+   *
+   * @param validation the given validation
+   * @param <E>        the type of the failure value
+   * @param <E1>       the type of the failure value
+   * @param <C>        the type of the success value
+   * @return the validation
+   */
+  public static final <E, E1, C> Validation<E1, Validation<E, C>> sequenceValidation(final Validation<E, Validation<E1, C>> validation) {
+    return validation.traverseValidation(identity());
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output on the left side of an either.
+   *
+   * @param f   the given function
+   * @param <C> the type of the left value
+   * @param <R> the type of the right value
+   * @return the list
+   */
+  public final <R, C> Either<Validation<E, C>, R> traverseEitherLeft(final F<T, Either<C, R>> f) {
+    return validation(
+        failure -> left(fail(failure)),
+        success -> f.f(success).left().map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <C> the type of the right value
+   * @return the list
+   */
+  public final <L, C> Either<L, Validation<E, C>> traverseEitherRight(final F<T, Either<L, C>> f) {
+    return validation(
+        failure -> right(fail(failure)),
+        success -> f.f(success).right().map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a function.
+   *
+   * @param f   the given function
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the function
+   */
+  public final <C, B> F<C, Validation<E, B>> traverseF(final F<T, F<C, B>> f) {
+    return validation(
+        failure -> constant(fail(failure)),
+        success -> andThen(f.f(success), Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as an IO.
+   *
+   * @param f   the given function
+   * @param <C> the type of the IO value
+   * @return the IO
+   */
+  public final <C> IO<Validation<E, C>> traverseIO(final F<T, IO<C>> f) {
+    return validation(
+        failure -> IOFunctions.unit(fail(failure)),
+        success -> IOFunctions.map(f.f(success), Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a list.
+   *
+   * @param f   the given function
+   * @param <C> the type of the list value
+   * @return the list
+   */
+  public final <C> List<Validation<E, C>> traverseList(final F<T, List<C>> f) {
+    return validation(
+        failure -> List.single(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as an option.
+   *
+   * @param f   the given function
+   * @param <C> the type of the option value
+   * @return the option
+   */
+  public final <C> Option<Validation<E, C>> traverseOption(F<T, Option<C>> f) {
+    return validation(
+        failure -> Option.some(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a P1.
+   *
+   * @param f   the given function
+   * @param <C> the type of the P1 value
+   * @return the P1
+   */
+  public final <C> P1<Validation<E, C>> traverseP1(final F<T, P1<C>> f) {
+    return validation(
+        failure -> p(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a seq.
+   *
+   * @param f   the given function
+   * @param <C> the type of the seq value
+   * @return the seq
+   */
+  public final <C> Seq<Validation<E, C>> traverseSeq(final F<T, Seq<C>> f) {
+    return validation(
+        failure -> Seq.single(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a set; use the given success and failure value ords to order the set.
+   *
+   * @param ordE the given failure value ord
+   * @param ordC the given success value ord
+   * @param f    the given function
+   * @param <C>  the type of the set value
+   * @return the set
+   */
+  public final <C> Set<Validation<E, C>> traverseSet(final Ord<E> ordE, final Ord<C> ordC, final F<T, Set<C>> f) {
+    final Ord<Validation<E, C>> ord = Ord.validationOrd(ordE, ordC);
+    return validation(
+        failure -> Set.single(ord, fail(failure)),
+        success -> f.f(success).map(ord, Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a stream.
+   *
+   * @param f   the given function
+   * @param <C> the type of the stream value
+   * @return the stream
+   */
+  public final <C> Stream<Validation<E, C>> traverseStream(final F<T, Stream<C>> f) {
+    return validation(
+        failure -> Stream.single(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a trampoline.
+   *
+   * @param f   the given function
+   * @param <C> the type of the trampoline value
+   * @return the trampoline
+   */
+  public final <C> Trampoline<Validation<E, C>> traverseTrampoline(final F<T, Trampoline<C>> f) {
+    return validation(
+        failure -> Trampoline.pure(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+  /**
+   * Traverse this validation with the given function and collect the output as a validation.
+   *
+   * @param f    the given function
+   * @param <E1> the type of the failure value
+   * @param <C>  the type of the seq value
+   * @return the validation
+   */
+  public final <E1, C> Validation<E1, Validation<E, C>> traverseValidation(final F<T, Validation<E1, C>> f) {
+    return validation(
+        failure -> success(fail(failure)),
+        success -> f.f(success).map(Validation::success));
+  }
+
+
+  public static <A, E> List<E> fails(List<Validation<E, ?>> list) {
+    return list.filter(Validation::isFail).map(v -> v.fail());
+  }
+
+  public static <A, E> List<A> successes(List<Validation<?, A>> list) {
+    return list.filter(Validation::isSuccess).map(v -> v.success());
+  }
 
   /**
    * A failing projection of a validation.
@@ -1268,7 +1552,7 @@ public static Validation<NumberFormatException, Short> parseShort(final String s
   }
 
   /**
-   * A function that parses a string into a short. 
+   * A function that parses a string into a short.
    */
   public static final F<String, Validation<NumberFormatException, Short>> parseShort = Validation::parseShort;
 
diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
new file mode 100644
index 00000000..0f1f3216
--- /dev/null
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -0,0 +1,209 @@
+package fj.data;
+
+import fj.control.Trampoline;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static fj.Function.constant;
+import static fj.Ord.*;
+import static fj.P.p;
+import static fj.data.Either.*;
+import static fj.data.Option.*;
+import static fj.data.Validation.sequenceEitherLeft;
+import static fj.data.Validation.sequenceEitherRight;
+import static fj.data.Validation.sequenceF;
+import static fj.data.Validation.sequenceIO;
+import static fj.data.Validation.sequenceList;
+import static fj.data.Validation.sequenceOption;
+import static fj.data.Validation.sequenceP1;
+import static fj.data.Validation.sequenceSeq;
+import static fj.data.Validation.sequenceSet;
+import static fj.data.Validation.sequenceStream;
+import static fj.data.Validation.sequenceTrampoline;
+import static fj.data.Validation.sequenceValidation;
+import static fj.data.Validation.*;
+import static org.junit.Assert.assertEquals;
+
+public class ValidationTest {
+
+  @Test
+  public void testSequenceEitherLeft() {
+    assertEquals(left(fail("zero")), sequenceEitherLeft(fail("zero")));
+    assertEquals(left(success("zero")), sequenceEitherLeft(success(left("zero"))));
+    assertEquals(right("zero"), sequenceEitherLeft(success(right("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherRight() {
+    assertEquals(right(fail("zero")), sequenceEitherRight(fail("zero")));
+    assertEquals(right(success("zero")), sequenceEitherRight(success(right("zero"))));
+    assertEquals(left("zero"), sequenceEitherRight(success(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceF() {
+    assertEquals(constant(fail("zero")).f(1), sequenceF(fail("zero")).f(1));
+    assertEquals(constant(success("zero")).f(1), sequenceF(success(constant("zero"))).f(1));
+  }
+
+  @Test
+  public void testSequenceIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(fail("zero"))).run(), sequenceIO(fail("zero")).run());
+    assertEquals(IOFunctions.lazy(constant(success("zero"))).run(), sequenceIO(success(IOFunctions.lazy(constant("zero")))).run());
+  }
+
+  @Test
+  public void testSequenceList() {
+    assertEquals(List.single(fail("zero")), sequenceList(fail("zero")));
+    assertEquals(List.nil(), sequenceList(success(List.nil())));
+    assertEquals(List.single(success("zero")), sequenceList(success(List.single("zero"))));
+    assertEquals(List.arrayList(success("zero"), success("one")), sequenceList(success(List.arrayList("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceOption() {
+    assertEquals(some(fail("zero")), sequenceOption(fail("zero")));
+    assertEquals(none(), sequenceOption(success(none())));
+    assertEquals(some(success("zero")), sequenceOption(success(some("zero"))));
+  }
+
+  @Test
+  public void testSequenceP1() {
+    assertEquals(p(fail("zero")), sequenceP1(fail("zero")));
+    assertEquals(p(success("zero")), sequenceP1(success(p("zero"))));
+  }
+
+  @Test
+  public void testSequenceSeq() {
+    assertEquals(Seq.single(fail("zero")), sequenceSeq(fail("zero")));
+    assertEquals(Seq.empty(), sequenceSeq(success(Seq.empty())));
+    assertEquals(Seq.single(success("zero")), sequenceSeq(success(Seq.single("zero"))));
+    assertEquals(Seq.arraySeq(success("zero"), success("one")), sequenceSeq(success(Seq.arraySeq("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceSet() {
+    assertEquals(Set.single(validationOrd(stringOrd, intOrd), fail("zero")), sequenceSet(stringOrd, intOrd, fail("zero")));
+    assertEquals(Set.empty(validationOrd(stringOrd, intOrd)), sequenceSet(stringOrd, intOrd, success(Set.empty(intOrd))));
+    assertEquals(Set.single(validationOrd(intOrd, stringOrd), success("zero")), sequenceSet(intOrd, stringOrd, success(Set.single(stringOrd, "zero"))));
+    assertEquals(Set.arraySet(validationOrd(intOrd, stringOrd), success("zero"), success("one")), sequenceSet(intOrd, stringOrd, Validation.success(Set.arraySet(stringOrd, "zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceStream() {
+    assertEquals(Stream.single(fail("zero")), sequenceStream(fail("zero")));
+    assertEquals(Stream.nil(), sequenceStream(success(Stream.nil())));
+    assertEquals(Stream.single(success("zero")), sequenceStream(success(Stream.single("zero"))));
+    assertEquals(Stream.arrayStream(success("zero"), success("one")), sequenceStream(success(Stream.arrayStream("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceTrampoline() {
+    assertEquals(Trampoline.pure(fail("zero")).run(), sequenceTrampoline(fail("zero")).run());
+    assertEquals(Trampoline.pure(success(0)).run(), sequenceTrampoline(success(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testSequenceValidation() {
+    assertEquals(success(fail("zero")), sequenceValidation(fail("zero")));
+    assertEquals(fail("zero"), sequenceValidation(success(fail("zero"))));
+    assertEquals(success(success(0)), sequenceValidation(success(success(0))));
+  }
+
+  @Test
+  public void testTraverseEitherLeft() {
+    assertEquals(left(fail("zero")), fail("zero").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(success(0)), success("zero").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(fail("zero")), fail("zero").traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), success("zero").traverseEitherLeft(constant(right(0))));
+  }
+
+  @Test
+  public void testTraverseEitherRight() {
+    assertEquals(right(fail("zero")), fail("zero").traverseEitherRight(constant(right(0))));
+    assertEquals(right(success(0)), success("zero").traverseEitherRight(constant(right(0))));
+    assertEquals(right(fail("zero")), fail("zero").traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), success("zero").traverseEitherRight(constant(left(0))));
+  }
+
+  @Test
+  public void testTraverseF() {
+    assertEquals(constant(fail("zero")).f(1), fail("zero").traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(success(0)).f(1), success("zero").traverseF(constant(constant(0))).f(1));
+  }
+
+  @Test
+  public void testTraverseIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(fail("zero"))).run(), fail("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(success(0))).run(), success("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseList() {
+    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.nil())));
+    assertEquals(List.nil(), success("zero").traverseList(constant(List.nil())));
+    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.single(0))));
+    assertEquals(List.single(success(0)), success("zero").traverseList(constant(List.single(0))));
+    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(List.arrayList(success(0), success(1)), success("zero").traverseList(constant(List.arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseOption() {
+    assertEquals(some(fail("zero")), fail("zero").traverseOption(constant(none())));
+    assertEquals(none(), success("zero").traverseOption(constant(none())));
+    assertEquals(some(fail("zero")), fail("zero").traverseOption(constant(some(0))));
+    assertEquals(some(success(0)), success("zero").traverseOption(constant(some(0))));
+  }
+
+  @Test
+  public void testTraverseP1() {
+    assertEquals(p(fail("zero")), fail("zero").traverseP1(constant(p(0))));
+    assertEquals(p(success(0)), success("zero").traverseP1(constant(p(0))));
+  }
+
+  @Test
+  public void testTraverseSeq() {
+    assertEquals(Seq.single(fail("zero")), fail("zero").traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.empty(), success("zero").traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.single(fail("zero")), fail("zero").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(success(0)), success("zero").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(fail("zero")), fail("zero").traverseSeq(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.arraySeq(success(0), success(1)), success("zero").traverseSeq(constant(Seq.arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testTraverseSet() {
+    assertEquals(Set.single(validationOrd(stringOrd, intOrd), fail("zero")), fail("zero").traverseSet(stringOrd, intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(validationOrd(stringOrd, intOrd)), Validation.<String, String>success("zero").traverseSet(stringOrd, intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.single(validationOrd(stringOrd, intOrd), fail("zero")), fail("zero").traverseSet(stringOrd, intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(validationOrd(stringOrd, intOrd), success(0)), Validation.<String, String>success("zero").traverseSet(stringOrd, intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(validationOrd(stringOrd, intOrd), fail("zero")), fail("zero").traverseSet(stringOrd, intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(validationOrd(stringOrd, intOrd), success(0), success(1)), Validation.<String, String>success("zero").traverseSet(stringOrd, intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+  }
+
+  @Test
+  public void testTraverseStream() {
+    assertEquals(Stream.single(fail("zero")), fail("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), success("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.single(fail("zero")), fail("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(success(0)), success("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(fail("zero")), fail("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(success(0), success(1)), success("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseTrampoline() {
+    assertEquals(Trampoline.pure(fail("zero")).run(), fail("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(success(0)).run(), success("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testTraverseValidation() {
+    assertEquals(Validation.<String, Validation<String, Integer>>success(fail("zero")), Validation.<String, String>fail("zero").traverseValidation(constant(Validation.<Integer, Integer>fail(0))));
+    assertEquals(Validation.<Integer, Validation<String, Integer>>fail(0), Validation.<String, String>success("zero").traverseValidation(constant(Validation.<Integer, Integer>fail(0))));
+    assertEquals(Validation.<String, Validation<String, Integer>>success(fail("zero")), Validation.<String, String>fail("zero").traverseValidation(constant(Validation.<Integer, Integer>success(0))));
+    assertEquals(Validation.<String, Validation<String, Integer>>success(success(0)), Validation.<String, String>success("zero").traverseValidation(constant(Validation.<Integer, Integer>success(0))));
+  }
+}

From cb99e095a2fbc2bcf9f527dbe1d272515c715b0c Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Thu, 23 Jul 2020 12:04:17 -0400
Subject: [PATCH 268/336] Fixes #403. Add fj.data.Option.sequence*,
 fj.data.Option.traverse*.

---
 core/src/main/java/fj/data/Option.java     | 351 +++++++++++++++++----
 core/src/test/java/fj/data/OptionTest.java | 242 ++++++++++++--
 2 files changed, 515 insertions(+), 78 deletions(-)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 1a170c2c..6b62d2cf 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -1,43 +1,24 @@
 package fj.data;
 
-import static fj.Bottom.error;
-import fj.F;
-import fj.F0;
-import fj.F2;
-import fj.P;
-import fj.P1;
-import fj.P2;
-import fj.P3;
-import fj.P4;
-import fj.P5;
-import fj.P6;
-import fj.P7;
-import fj.P8;
-import fj.Unit;
-import fj.Show;
+import fj.*;
+import fj.control.Trampoline;
+import fj.data.optic.*;
 import fj.function.Effect1;
-import fj.Equal;
-import fj.Ord;
-import fj.Hash;
-import fj.data.optic.Prism;
-import fj.data.optic.PPrism;
+
+import java.lang.Class;
+import java.util.*;
+
+import static fj.Bottom.error;
 import static fj.Function.*;
 import static fj.P.p;
+import static fj.Show.optionShow;
 import static fj.Unit.unit;
-import static fj.data.List.cons;
-import static fj.data.List.cons_;
-import static fj.data.Validation.parseByte;
-import static fj.data.Validation.parseDouble;
-import static fj.data.Validation.parseFloat;
-import static fj.data.Validation.parseInt;
-import static fj.data.Validation.parseLong;
-import static fj.data.Validation.parseShort;
-import static fj.data.optic.Prism.prism;
+import static fj.control.Trampoline.pure;
+import static fj.data.Either.*;
+import static fj.data.List.*;
+import static fj.data.Validation.*;
 import static fj.data.optic.PPrism.pPrism;
-import static fj.Show.optionShow;
-
-import java.util.Collection;
-import java.util.Iterator;
+import static fj.data.optic.Prism.prism;
 
 /**
  * An optional value that may be none (no value) or some (a value). This type is a replacement for
@@ -411,45 +392,307 @@ public final <B> Option<B> sequence(final Option<B> o) {
     return bind(c);
   }
 
-  public final <L, B> Either<L, Option<B>> traverseEither(F<A, Either<L, B>> f) {
-    return map(a -> f.f(a).right().map(Option::some)).orSome(Either.right(none()));
+  /**
+   * Sequence the given option and collect the output on the right side of an either.
+   *
+   * @param option the given option
+   * @param <R>    the type of the right value
+   * @param <B>    the type of the left value
+   * @return the either
+   */
+  public static final <R, B> Either<Option<B>, R> sequenceEitherLeft(final Option<Either<B, R>> option) {
+    return option.traverseEitherLeft(identity());
+  }
+
+  /**
+   * Sequence the given option and collect the output on the left side of an either.
+   *
+   * @param option the given option
+   * @param <B>    the type of the right value
+   * @param <L>    the type of the left value
+   * @return the either
+   */
+  public static final <L, B> Either<L, Option<B>> sequenceEitherRight(final Option<Either<L, B>> option) {
+    return option.traverseEitherRight(identity());
+  }
+
+  /**
+   * Sequence the given option and collect the output as a function.
+   *
+   * @param option the given option
+   * @param <C>    the type of the input value
+   * @param <B>    the type of the output value
+   * @return the either
+   */
+  public static final <C, B> F<C, Option<B>> sequenceF(final Option<F<C, B>> option) {
+    return option.traverseF(identity());
+  }
+
+  /**
+   * Sequence the given option and collect the output as an IO.
+   *
+   * @param option the given option
+   * @param <B>    the type of the IO value
+   * @return the IO
+   */
+  public static final <B> IO<Option<B>> sequenceIO(final Option<IO<B>> option) {
+    return option.traverseIO(identity());
+  }
+
+  /**
+   * Sequence the given option and collect the output as an list.
+   *
+   * @param option the given option
+   * @param <B>    the type of the list value
+   * @return the list
+   */
+  public static final <B> List<Option<B>> sequenceList(final Option<List<B>> option) {
+    return option.traverseList(identity());
   }
 
-  public final <B> IO<Option<B>> traverseIO(F<A, IO<B>> f) {
-    return map(a -> IOFunctions.map(f.f(a), Option::some)).orSome(IOFunctions.lazy(Option::none));
+  /**
+   * Sequence the given option and collect the output as an option.
+   *
+   * @param option the given option
+   * @param <B>    the type of the option value
+   * @return the option
+   */
+  public static final <B> Option<Option<B>> sequenceOption(final Option<Option<B>> option) {
+    return option.traverseOption(identity());
   }
 
-  public final <B> List<Option<B>> traverseList(F<A, List<B>> f) {
-    return map(a -> f.f(a).map(Option::some)).orSome(List.list());
+  /**
+   * Sequence the given option and collect the output as a P1.
+   *
+   * @param option the given option
+   * @param <B>    the type of the P1 value
+   * @return the P1
+   */
+  public static final <B> P1<Option<B>> sequenceP1(final Option<P1<B>> option) {
+    return option.traverseP1(identity());
   }
 
-  public final <B> Option<Option<B>> traverseOption(F<A, Option<B>> f) {
-    return map(f);
+  /**
+   * Sequence the given option and collect the output as a seq.
+   *
+   * @param option the given option
+   * @param <B>    the type of the seq value
+   * @return the seq
+   */
+  public static final <B> Seq<Option<B>> sequenceSeq(final Option<Seq<B>> option) {
+    return option.traverseSeq(identity());
   }
 
-  public final <B> Stream<Option<B>> traverseStream(F<A, Stream<B>> f) {
-    return map(a -> f.f(a).map(Option::some)).orSome(Stream.nil());
+  /**
+   * Sequence the given option and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord    the given ord
+   * @param option the given option
+   * @param <B>    the type of the set value
+   * @return the either
+   */
+  public static final <B> Set<Option<B>> sequenceSet(final Ord<B> ord, final Option<Set<B>> option) {
+    return option.traverseSet(ord, identity());
   }
 
-  public final <B> P1<Option<B>> traverseP1(F<A, P1<B>> f) {
-    return map(a -> f.f(a).map(Option::some)).orSome(p(none()));
+  /**
+   * Sequence the given option and collect the output as a stream.
+   *
+   * @param option the given option
+   * @param <B>    the type of the stream value
+   * @return the stream
+   */
+  public static final <B> Stream<Option<B>> sequenceStream(final Option<Stream<B>> option) {
+    return option.traverseStream(identity());
   }
 
-  public final <B> Seq<Option<B>> traverseSeq(F<A, Seq<B>> f) {
-    return map(a -> f.f(a).map(Option::some)).orSome(Seq.empty());
+  /**
+   * Sequence the given option and collect the output as a trampoline.
+   *
+   * @param option the given trampoline
+   * @param <B>    the type of the stream value
+   * @return the stream
+   */
+  public static final <B> Trampoline<Option<B>> sequenceTrampoline(final Option<Trampoline<B>> option) {
+    return option.traverseTrampoline(identity());
   }
 
-  public final <B> Set<Option<B>> traverseSet(Ord<B> ord, F<A, Set<B>> f) {
-    Ord<Option<B>> optOrd = Ord.optionOrd(ord);
-    return map(a -> f.f(a).map(optOrd, Option::some)).orSome(Set.empty(optOrd));
+  /**
+   * Sequence the given option and collect the output as a validation.
+   *
+   * @param option the given option
+   * @param <E>    the type of the failure value
+   * @param <B>    the type of the success value
+   * @return the validation
+   */
+  public static final <E, B> Validation<E, Option<B>> sequenceValidation(final Option<Validation<E, B>> option) {
+    return option.traverseValidation(identity());
   }
 
-  public final <B> F2<Ord<B>, F<A, Set<B>>, Set<Option<B>>> traverseSet() {
-    return this::traverseSet;
+  /**
+   * Traverse this option with the given function and collect the output on the left side of an either.
+   *
+   * @param f   the given function
+   * @param <R> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public final <R, B> Either<Option<B>, R> traverseEitherLeft(final F<A, Either<B, R>> f) {
+    return option(
+        left(none()),
+        a -> f.f(a).left().map(Option::some));
   }
 
-  public final <E, B> Validation<E, Option<B>> traverseValidation(F<A, Validation<E, B>> f) {
-    return map(a -> f.f(a).map(Option::some)).orSome(Validation.success(none()));
+  /**
+   * Traverse this option with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public final <L, B> Either<L, Option<B>> traverseEitherRight(final F<A, Either<L, B>> f) {
+    return option(
+        right(none()),
+        a -> f.f(a).right().map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a function.
+   *
+   * @param f   the given function
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the function
+   */
+  public final <C, B> F<C, Option<B>> traverseF(final F<A, F<C, B>> f) {
+    return option(
+        constant(none()),
+        a -> andThen(f.f(a), Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as an IO.
+   *
+   * @param f   the given function
+   * @param <B> the type of the IO value
+   * @return the IO
+   */
+  public final <B> IO<Option<B>> traverseIO(final F<A, IO<B>> f) {
+    return option(
+        IOFunctions.lazy(Option::none),
+        a -> IOFunctions.map(f.f(a), Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a list.
+   *
+   * @param f   the given function
+   * @param <B> the type of the list value
+   * @return the list
+   */
+  public final <B> List<Option<B>> traverseList(final F<A, List<B>> f) {
+    return option(
+        List.single(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as an option.
+   *
+   * @param f   the given function
+   * @param <B> the type of the option value
+   * @return the option
+   */
+  public final <B> Option<Option<B>> traverseOption(final F<A, Option<B>> f) {
+    return option(
+        some(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a P1.
+   *
+   * @param f   the given function
+   * @param <B> the type of the P1 value
+   * @return the P1
+   */
+  public final <B> P1<Option<B>> traverseP1(final F<A, P1<B>> f) {
+    return option(
+        p(none()),
+        (F<A, P1<Option<B>>>) a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output a seq.
+   *
+   * @param f   the given function
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public final <B> Seq<Option<B>> traverseSeq(final F<A, Seq<B>> f) {
+    return option(
+        Seq.single(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord the given ord
+   * @param f   the given function
+   * @param <B> the type of the set value
+   * @return the set
+   */
+  public final <B> Set<Option<B>> traverseSet(final Ord<B> ord, final F<A, Set<B>> f) {
+    final Ord<Option<B>> ordOption = Ord.optionOrd(ord);
+    return option(
+        Set.single(ordOption, none()),
+        a -> f.f(a).map(ordOption, Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a stream.
+   *
+   * @param f   the given function
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public final <B> Stream<Option<B>> traverseStream(final F<A, Stream<B>> f) {
+    return option(
+        Stream.single(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a trampoline.
+   *
+   * @param f   the given function
+   * @param <B> the type of the trampoline value
+   * @return the trampoline
+   */
+  public final <B> Trampoline<Option<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
+    return option(
+        pure(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  /**
+   * Traverse this option with the given function and collect the output as a validation.
+   *
+   * @param f   the given function
+   * @param <E> the type of the failure value
+   * @param <B> the type of the success value
+   * @return the validation
+   */
+  public final <E, B> Validation<E, Option<B>> traverseValidation(final F<A, Validation<E, B>> f) {
+    return option(
+        success(none()),
+        a -> f.f(a).map(Option::some));
+  }
+
+  public final <B> F2<Ord<B>, F<A, Set<B>>, Set<Option<B>>> traverseSet() {
+    return this::traverseSet;
   }
 
   /**
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index 0966ece0..403cbbd1 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -1,21 +1,35 @@
 package fj.data;
 
+import fj.control.Trampoline;
 import org.junit.Test;
 
-import static fj.data.List.arrayList;
-import static fj.data.List.nil;
-import static fj.data.Option.none;
+import java.io.IOException;
+
+import static fj.Function.constant;
+import static fj.Ord.*;
+import static fj.P.p;
+import static fj.data.Either.*;
+import static fj.data.List.*;
 import static fj.data.Option.sequence;
-import static fj.data.Option.some;
+import static fj.data.Option.sequenceF;
+import static fj.data.Option.sequenceIO;
+import static fj.data.Option.sequenceList;
+import static fj.data.Option.sequenceOption;
+import static fj.data.Option.sequenceP1;
+import static fj.data.Option.sequenceSeq;
+import static fj.data.Option.sequenceSet;
+import static fj.data.Option.sequenceStream;
+import static fj.data.Option.sequenceTrampoline;
+import static fj.data.Option.sequenceValidation;
+import static fj.data.Option.*;
 import static fj.data.Validation.fail;
-import static fj.data.Validation.success;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static fj.data.Validation.*;
+import static org.junit.Assert.*;
 
 /**
  * Created by MarkPerry on 15/01/2015.
  */
-public class OptionTest {
+public final class OptionTest {
 
     @Test
     public void equals() {
@@ -32,21 +46,201 @@ public void traverseList() {
         assertTrue(actual.equals(expected));
     }
 
-    @Test
-    public void sequenceListTest() {
-        assertEquals(some(nil()), sequence(nil()));
-        assertEquals(none(), sequence(arrayList(none())));
-        assertEquals(some(arrayList(1)), sequence(arrayList(some(1))));
-        assertEquals(none(), sequence(arrayList(none(), none())));
-        assertEquals(none(), sequence(arrayList(some(1), none())));
-        assertEquals(none(), sequence(arrayList(none(), some(2))));
-        assertEquals(some(arrayList(1, 2)), sequence(arrayList(some(1), some(2))));
-    }
+  @Test
+  public void sequenceListTest() {
+    assertEquals(some(nil()), sequence(nil()));
+    assertEquals(none(), sequence(arrayList(none())));
+    assertEquals(some(arrayList(1)), sequence(arrayList(some(1))));
+    assertEquals(none(), sequence(arrayList(none(), none())));
+    assertEquals(none(), sequence(arrayList(some(1), none())));
+    assertEquals(none(), sequence(arrayList(none(), some(2))));
+    assertEquals(some(arrayList(1, 2)), sequence(arrayList(some(1), some(2))));
+  }
 
-    @Test
-    public void sequenceValidationTest() {
-        assertEquals(some(fail(1)), sequence(Validation.<Integer, Option<String>>fail(1)));
-        assertEquals(none(), sequence(Validation.<Integer, Option<String>>success(none())));
-        assertEquals(some(success("string")), sequence(Validation.<Integer, Option<String>>success(some("string"))));
-    }
+  @Test
+  public void sequenceValidationTest() {
+    assertEquals(some(fail(1)), sequence(Validation.<Integer, Option<String>>fail(1)));
+    assertEquals(none(), sequence(Validation.<Integer, Option<String>>success(none())));
+    assertEquals(some(success("string")), sequence(Validation.<Integer, Option<String>>success(some("string"))));
+  }
+
+  @Test
+  public void testSequenceEitherLeft() {
+    assertEquals(left(none()), sequenceEitherLeft(none()));
+    assertEquals(left(some("0")), sequenceEitherLeft(some(left("0"))));
+    assertEquals(right("0"), sequenceEitherLeft(some(right("0"))));
+  }
+
+  @Test
+  public void testSequenceEitherRight() {
+    assertEquals(right(none()), sequenceEitherRight(none()));
+    assertEquals(right(some("0")), sequenceEitherRight(some(right("0"))));
+    assertEquals(left("0"), sequenceEitherRight(some(left("0"))));
+  }
+
+  @Test
+  public void testSequenceF() {
+    assertEquals(constant(none()).f(1), sequenceF(none()).f(1));
+    assertEquals(constant(some("0")).f(1), sequenceF(some(constant("0"))).f(1));
+  }
+
+  @Test
+  public void testSequenceIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(none())).run(), sequenceIO(none()).run());
+    assertEquals(IOFunctions.lazy(constant(some("0"))).run(), sequenceIO(some(IOFunctions.lazy(constant("0")))).run());
+  }
+
+  @Test
+  public void testSequenceList() {
+    assertEquals(List.arrayList(none()), sequenceList(none()));
+    assertEquals(List.nil(), sequenceList(some(List.nil())));
+    assertEquals(List.arrayList(some("0")), sequenceList(some(List.single("0"))));
+    assertEquals(List.arrayList(some("0"), some("1")), sequenceList(some(List.arrayList("0", "1"))));
+  }
+
+  @Test
+  public void testSequenceOption() {
+    assertEquals(some(none()), sequenceOption(none()));
+    assertEquals(none(), sequenceOption(some(none())));
+    assertEquals(some(some("0")), sequenceOption(some(some("0"))));
+  }
+
+  @Test
+  public void testSequenceP1() {
+    assertEquals(p(none()), sequenceP1(none()));
+    assertEquals(p(some("0")), sequenceP1(some(p("0"))));
+  }
+
+  @Test
+  public void testSequenceSeq() {
+    assertEquals(Seq.arraySeq(none()), sequenceSeq(none()));
+    assertEquals(Seq.empty(), sequenceSeq(some(Seq.empty())));
+    assertEquals(Seq.arraySeq(some("0")), sequenceSeq(some(Seq.single("0"))));
+    assertEquals(Seq.arraySeq(some("0"), some("1")), sequenceSeq(some(Seq.arraySeq("0", "1"))));
+  }
+
+  @Test
+  public void testSequenceSet() {
+    assertEquals(Set.arraySet(optionOrd(stringOrd), none()), sequenceSet(stringOrd, none()));
+    assertEquals(Set.empty(optionOrd(stringOrd)), sequenceSet(stringOrd, some(Set.empty(stringOrd))));
+    assertEquals(Set.arraySet(optionOrd(stringOrd), some("0")), sequenceSet(stringOrd, some(Set.single(stringOrd, "0"))));
+    assertEquals(Set.arraySet(optionOrd(stringOrd), some("0"), some("1")), sequenceSet(stringOrd, some(Set.arraySet(stringOrd, "0", "1"))));
+  }
+
+  @Test
+  public void testSequenceStream() {
+    assertEquals(Stream.arrayStream(none()), sequenceStream(none()));
+    assertEquals(Stream.nil(), sequenceStream(some(Stream.nil())));
+    assertEquals(Stream.arrayStream(some("0")), sequenceStream(some(Stream.single("0"))));
+    assertEquals(Stream.arrayStream(some("0"), some("1")), sequenceStream(some(Stream.arrayStream("0", "1"))));
+  }
+
+  @Test
+  public void testSequenceTrampoline() {
+    assertEquals(Trampoline.pure(none()).run(), sequenceTrampoline(none()).run());
+    assertEquals(Trampoline.pure(some(0)).run(), sequenceTrampoline(some(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testSequenceValidation() {
+    assertEquals(Validation.success(none()), sequenceValidation(none()));
+    assertEquals(Validation.fail(0), sequenceValidation(some(Validation.fail(0))));
+    assertEquals(Validation.success(some(0)), sequenceValidation(some(Validation.success(0))));
+  }
+
+  @Test
+  public void testTraverseEitherLeft() {
+    assertEquals(left(none()), none().traverseEitherLeft(constant(left(0))));
+    assertEquals(left(some(0)), some("0").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(none()), none().traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), some("0").traverseEitherLeft(constant(right(0))));
+  }
+
+  @Test
+  public void testTraverseEitherRight() {
+    assertEquals(right(none()), none().traverseEitherRight(constant(right(0))));
+    assertEquals(right(some(0)), some("0").traverseEitherRight(constant(right(0))));
+    assertEquals(right(none()), none().traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), some("0").traverseEitherRight(constant(left(0))));
+  }
+
+  @Test
+  public void testTraverseF() {
+    assertEquals(constant(none()).f(1), none().traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(some(0)).f(1), some("0").traverseF(constant(constant(0))).f(1));
+  }
+
+  @Test
+  public void testTraverseIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(none())).run(), none().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(some(0))).run(), some("0").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseList() {
+    assertEquals(List.arrayList(none()), none().traverseList(constant(List.nil())));
+    assertEquals(List.nil(), some("0").traverseList(constant(List.nil())));
+    assertEquals(List.arrayList(none()), none().traverseList(constant(List.single(0))));
+    assertEquals(List.arrayList(some(0)), some("0").traverseList(constant(List.single(0))));
+    assertEquals(List.arrayList(none()), none().traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(List.arrayList(some(0), some(1)), some("0").traverseList(constant(List.arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseOption() {
+    assertEquals(some(none()), none().traverseOption(constant(none())));
+    assertEquals(none(), some("0").traverseOption(constant(none())));
+    assertEquals(some(none()), none().traverseOption(constant(some(0))));
+    assertEquals(some(some(0)), some("0").traverseOption(constant(some(0))));
+  }
+
+  @Test
+  public void testTraverseP1() {
+    assertEquals(p(none()), none().traverseP1(constant(p(0))));
+    assertEquals(p(some(0)), some("0").traverseP1(constant(p(0))));
+  }
+
+  @Test
+  public void testTraverseSeq() {
+    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.empty(), some("0").traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.arraySeq(some(0)), some("0").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.arraySeq(some(0), some(1)), some("0").traverseSeq(constant(Seq.arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testTraverseSet() {
+    assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(optionOrd(intOrd)), some("0").traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), some(0)), some("0").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), some(0), some(1)), some("0").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+  }
+
+  @Test
+  public void testTraverseStream() {
+    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), some("0").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.arrayStream(some(0)), some("0").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(some(0), some(1)), some("0").traverseStream(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseTrampoline() {
+    assertEquals(Trampoline.pure(none()).run(), none().traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(some(0)).run(), some("0").traverseTrampoline(constant(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testTraverseValidation() {
+    assertEquals(success(none()), none().traverseValidation(constant(Validation.fail(0))));
+    assertEquals(fail(0), some("0").traverseValidation(constant(Validation.fail(0))));
+    assertEquals(success(none()), none().traverseValidation(constant(Validation.success(0))));
+    assertEquals(success(some(0)), some("0").traverseValidation(constant(Validation.success(0))));
+  }
 }

From 225622c0e9ac4544868d341455ea5e6894311a10 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Thu, 23 Jul 2020 13:38:44 -0400
Subject: [PATCH 269/336] Fixes #403. Add fj.data.Option.sequence*,
 fj.data.Option.traverse*; correct comment, distinguish between 0 and 0.

---
 core/src/main/java/fj/data/Option.java     |   4 +-
 core/src/test/java/fj/data/OptionTest.java | 106 +++++++++++----------
 2 files changed, 56 insertions(+), 54 deletions(-)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 6b62d2cf..655463b7 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -393,7 +393,7 @@ public final <B> Option<B> sequence(final Option<B> o) {
   }
 
   /**
-   * Sequence the given option and collect the output on the right side of an either.
+   * Sequence the given option and collect the output on the left side of an either.
    *
    * @param option the given option
    * @param <R>    the type of the right value
@@ -405,7 +405,7 @@ public static final <R, B> Either<Option<B>, R> sequenceEitherLeft(final Option<
   }
 
   /**
-   * Sequence the given option and collect the output on the left side of an either.
+   * Sequence the given option and collect the output on the right side of an either.
    *
    * @param option the given option
    * @param <B>    the type of the right value
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index 403cbbd1..db37f1ed 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -11,6 +11,8 @@
 import static fj.data.Either.*;
 import static fj.data.List.*;
 import static fj.data.Option.sequence;
+import static fj.data.Option.sequenceEitherLeft;
+import static fj.data.Option.sequenceEitherRight;
 import static fj.data.Option.sequenceF;
 import static fj.data.Option.sequenceIO;
 import static fj.data.Option.sequenceList;
@@ -67,72 +69,72 @@ public void sequenceValidationTest() {
   @Test
   public void testSequenceEitherLeft() {
     assertEquals(left(none()), sequenceEitherLeft(none()));
-    assertEquals(left(some("0")), sequenceEitherLeft(some(left("0"))));
-    assertEquals(right("0"), sequenceEitherLeft(some(right("0"))));
+    assertEquals(left(some("zero")), sequenceEitherLeft(some(left("zero"))));
+    assertEquals(right("zero"), sequenceEitherLeft(some(right("zero"))));
   }
 
   @Test
   public void testSequenceEitherRight() {
     assertEquals(right(none()), sequenceEitherRight(none()));
-    assertEquals(right(some("0")), sequenceEitherRight(some(right("0"))));
-    assertEquals(left("0"), sequenceEitherRight(some(left("0"))));
+    assertEquals(right(some("zero")), sequenceEitherRight(some(right("zero"))));
+    assertEquals(left("zero"), sequenceEitherRight(some(left("zero"))));
   }
 
   @Test
   public void testSequenceF() {
     assertEquals(constant(none()).f(1), sequenceF(none()).f(1));
-    assertEquals(constant(some("0")).f(1), sequenceF(some(constant("0"))).f(1));
+    assertEquals(constant(some("zero")).f(1), sequenceF(some(constant("zero"))).f(1));
   }
 
   @Test
   public void testSequenceIO() throws IOException {
     assertEquals(IOFunctions.lazy(constant(none())).run(), sequenceIO(none()).run());
-    assertEquals(IOFunctions.lazy(constant(some("0"))).run(), sequenceIO(some(IOFunctions.lazy(constant("0")))).run());
+    assertEquals(IOFunctions.lazy(constant(some("zero"))).run(), sequenceIO(some(IOFunctions.lazy(constant("zero")))).run());
   }
 
   @Test
   public void testSequenceList() {
-    assertEquals(List.arrayList(none()), sequenceList(none()));
+    assertEquals(List.single(none()), sequenceList(none()));
     assertEquals(List.nil(), sequenceList(some(List.nil())));
-    assertEquals(List.arrayList(some("0")), sequenceList(some(List.single("0"))));
-    assertEquals(List.arrayList(some("0"), some("1")), sequenceList(some(List.arrayList("0", "1"))));
+    assertEquals(List.single(some("zero")), sequenceList(some(List.single("zero"))));
+    assertEquals(List.arrayList(some("zero"), some("one")), sequenceList(some(List.arrayList("zero", "one"))));
   }
 
   @Test
   public void testSequenceOption() {
     assertEquals(some(none()), sequenceOption(none()));
     assertEquals(none(), sequenceOption(some(none())));
-    assertEquals(some(some("0")), sequenceOption(some(some("0"))));
+    assertEquals(some(some("zero")), sequenceOption(some(some("zero"))));
   }
 
   @Test
   public void testSequenceP1() {
     assertEquals(p(none()), sequenceP1(none()));
-    assertEquals(p(some("0")), sequenceP1(some(p("0"))));
+    assertEquals(p(some("zero")), sequenceP1(some(p("zero"))));
   }
 
   @Test
   public void testSequenceSeq() {
-    assertEquals(Seq.arraySeq(none()), sequenceSeq(none()));
+    assertEquals(Seq.single(none()), sequenceSeq(none()));
     assertEquals(Seq.empty(), sequenceSeq(some(Seq.empty())));
-    assertEquals(Seq.arraySeq(some("0")), sequenceSeq(some(Seq.single("0"))));
-    assertEquals(Seq.arraySeq(some("0"), some("1")), sequenceSeq(some(Seq.arraySeq("0", "1"))));
+    assertEquals(Seq.single(some("zero")), sequenceSeq(some(Seq.single("zero"))));
+    assertEquals(Seq.arraySeq(some("zero"), some("one")), sequenceSeq(some(Seq.arraySeq("zero", "one"))));
   }
 
   @Test
   public void testSequenceSet() {
     assertEquals(Set.arraySet(optionOrd(stringOrd), none()), sequenceSet(stringOrd, none()));
     assertEquals(Set.empty(optionOrd(stringOrd)), sequenceSet(stringOrd, some(Set.empty(stringOrd))));
-    assertEquals(Set.arraySet(optionOrd(stringOrd), some("0")), sequenceSet(stringOrd, some(Set.single(stringOrd, "0"))));
-    assertEquals(Set.arraySet(optionOrd(stringOrd), some("0"), some("1")), sequenceSet(stringOrd, some(Set.arraySet(stringOrd, "0", "1"))));
+    assertEquals(Set.arraySet(optionOrd(stringOrd), some("zero")), sequenceSet(stringOrd, some(Set.single(stringOrd, "zero"))));
+    assertEquals(Set.arraySet(optionOrd(stringOrd), some("zero"), some("one")), sequenceSet(stringOrd, some(Set.arraySet(stringOrd, "zero", "one"))));
   }
 
   @Test
   public void testSequenceStream() {
-    assertEquals(Stream.arrayStream(none()), sequenceStream(none()));
+    assertEquals(Stream.single(none()), sequenceStream(none()));
     assertEquals(Stream.nil(), sequenceStream(some(Stream.nil())));
-    assertEquals(Stream.arrayStream(some("0")), sequenceStream(some(Stream.single("0"))));
-    assertEquals(Stream.arrayStream(some("0"), some("1")), sequenceStream(some(Stream.arrayStream("0", "1"))));
+    assertEquals(Stream.single(some("zero")), sequenceStream(some(Stream.single("zero"))));
+    assertEquals(Stream.arrayStream(some("zero"), some("one")), sequenceStream(some(Stream.arrayStream("zero", "one"))));
   }
 
   @Test
@@ -151,96 +153,96 @@ public void testSequenceValidation() {
   @Test
   public void testTraverseEitherLeft() {
     assertEquals(left(none()), none().traverseEitherLeft(constant(left(0))));
-    assertEquals(left(some(0)), some("0").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(some(0)), some("zero").traverseEitherLeft(constant(left(0))));
     assertEquals(left(none()), none().traverseEitherLeft(constant(right(0))));
-    assertEquals(right(0), some("0").traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), some("zero").traverseEitherLeft(constant(right(0))));
   }
 
   @Test
   public void testTraverseEitherRight() {
     assertEquals(right(none()), none().traverseEitherRight(constant(right(0))));
-    assertEquals(right(some(0)), some("0").traverseEitherRight(constant(right(0))));
+    assertEquals(right(some(0)), some("zero").traverseEitherRight(constant(right(0))));
     assertEquals(right(none()), none().traverseEitherRight(constant(left(0))));
-    assertEquals(left(0), some("0").traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), some("zero").traverseEitherRight(constant(left(0))));
   }
 
   @Test
   public void testTraverseF() {
     assertEquals(constant(none()).f(1), none().traverseF(constant(constant(0))).f(1));
-    assertEquals(constant(some(0)).f(1), some("0").traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(some(0)).f(1), some("zero").traverseF(constant(constant(0))).f(1));
   }
 
   @Test
   public void testTraverseIO() throws IOException {
     assertEquals(IOFunctions.lazy(constant(none())).run(), none().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
-    assertEquals(IOFunctions.lazy(constant(some(0))).run(), some("0").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(some(0))).run(), some("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
   }
 
   @Test
   public void testTraverseList() {
-    assertEquals(List.arrayList(none()), none().traverseList(constant(List.nil())));
-    assertEquals(List.nil(), some("0").traverseList(constant(List.nil())));
-    assertEquals(List.arrayList(none()), none().traverseList(constant(List.single(0))));
-    assertEquals(List.arrayList(some(0)), some("0").traverseList(constant(List.single(0))));
-    assertEquals(List.arrayList(none()), none().traverseList(constant(List.arrayList(0, 1))));
-    assertEquals(List.arrayList(some(0), some(1)), some("0").traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(List.single(none()), none().traverseList(constant(List.nil())));
+    assertEquals(List.nil(), some("zero").traverseList(constant(List.nil())));
+    assertEquals(List.single(none()), none().traverseList(constant(List.single(0))));
+    assertEquals(List.single(some(0)), some("zero").traverseList(constant(List.single(0))));
+    assertEquals(List.single(none()), none().traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(List.arrayList(some(0), some(1)), some("zero").traverseList(constant(List.arrayList(0, 1))));
   }
 
   @Test
   public void testTraverseOption() {
     assertEquals(some(none()), none().traverseOption(constant(none())));
-    assertEquals(none(), some("0").traverseOption(constant(none())));
+    assertEquals(none(), some("zero").traverseOption(constant(none())));
     assertEquals(some(none()), none().traverseOption(constant(some(0))));
-    assertEquals(some(some(0)), some("0").traverseOption(constant(some(0))));
+    assertEquals(some(some(0)), some("zero").traverseOption(constant(some(0))));
   }
 
   @Test
   public void testTraverseP1() {
     assertEquals(p(none()), none().traverseP1(constant(p(0))));
-    assertEquals(p(some(0)), some("0").traverseP1(constant(p(0))));
+    assertEquals(p(some(0)), some("zero").traverseP1(constant(p(0))));
   }
 
   @Test
   public void testTraverseSeq() {
-    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.empty())));
-    assertEquals(Seq.empty(), some("0").traverseSeq(constant(Seq.empty())));
-    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.single(0))));
-    assertEquals(Seq.arraySeq(some(0)), some("0").traverseSeq(constant(Seq.single(0))));
-    assertEquals(Seq.arraySeq(none()), none().traverseSeq(constant(Seq.arraySeq(0, 1))));
-    assertEquals(Seq.arraySeq(some(0), some(1)), some("0").traverseSeq(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.single(none()), none().traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.empty(), some("zero").traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.single(none()), none().traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(some(0)), some("zero").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(none()), none().traverseSeq(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.arraySeq(some(0), some(1)), some("zero").traverseSeq(constant(Seq.arraySeq(0, 1))));
   }
 
   @Test
   public void testTraverseSet() {
     assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.empty(intOrd))));
-    assertEquals(Set.empty(optionOrd(intOrd)), some("0").traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(optionOrd(intOrd)), some("zero").traverseSet(intOrd, constant(Set.empty(intOrd))));
     assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.single(intOrd, 0))));
-    assertEquals(Set.arraySet(optionOrd(intOrd), some(0)), some("0").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), some(0)), some("zero").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
     assertEquals(Set.arraySet(optionOrd(intOrd), none()), none().traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
-    assertEquals(Set.arraySet(optionOrd(intOrd), some(0), some(1)), some("0").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(optionOrd(intOrd), some(0), some(1)), some("zero").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
   }
 
   @Test
   public void testTraverseStream() {
-    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.nil())));
-    assertEquals(Stream.nil(), some("0").traverseStream(constant(Stream.nil())));
-    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.single(0))));
-    assertEquals(Stream.arrayStream(some(0)), some("0").traverseStream(constant(Stream.single(0))));
-    assertEquals(Stream.arrayStream(none()), none().traverseStream(constant(Stream.arrayStream(0, 1))));
-    assertEquals(Stream.arrayStream(some(0), some(1)), some("0").traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.single(none()), none().traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), some("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.single(none()), none().traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(some(0)), some("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(none()), none().traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(some(0), some(1)), some("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
   }
 
   @Test
   public void testTraverseTrampoline() {
     assertEquals(Trampoline.pure(none()).run(), none().traverseTrampoline(constant(Trampoline.pure(0))).run());
-    assertEquals(Trampoline.pure(some(0)).run(), some("0").traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(some(0)).run(), some("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
   }
 
   @Test
   public void testTraverseValidation() {
     assertEquals(success(none()), none().traverseValidation(constant(Validation.fail(0))));
-    assertEquals(fail(0), some("0").traverseValidation(constant(Validation.fail(0))));
+    assertEquals(fail(0), some("zero").traverseValidation(constant(Validation.fail(0))));
     assertEquals(success(none()), none().traverseValidation(constant(Validation.success(0))));
-    assertEquals(success(some(0)), some("0").traverseValidation(constant(Validation.success(0))));
+    assertEquals(success(some(0)), some("zero").traverseValidation(constant(Validation.success(0))));
   }
 }

From f9ec6ee20804e1db8b6a4c0c238a5a51adbbe888 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Thu, 23 Jul 2020 17:56:43 -0400
Subject: [PATCH 270/336] Fixes #403. Add fj.data.Option.sequence*,
 fj.data.Option.traverse*; add bind tests.

---
 core/src/test/java/fj/data/OptionTest.java | 187 +++++++++++++++++++--
 1 file changed, 174 insertions(+), 13 deletions(-)

diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index db37f1ed..d028d4f6 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -1,5 +1,6 @@
 package fj.data;
 
+import fj.P;
 import fj.control.Trampoline;
 import org.junit.Test;
 
@@ -7,22 +8,11 @@
 
 import static fj.Function.constant;
 import static fj.Ord.*;
-import static fj.P.p;
+import static fj.P.*;
 import static fj.data.Either.*;
 import static fj.data.List.*;
+import static fj.data.Option.iif;
 import static fj.data.Option.sequence;
-import static fj.data.Option.sequenceEitherLeft;
-import static fj.data.Option.sequenceEitherRight;
-import static fj.data.Option.sequenceF;
-import static fj.data.Option.sequenceIO;
-import static fj.data.Option.sequenceList;
-import static fj.data.Option.sequenceOption;
-import static fj.data.Option.sequenceP1;
-import static fj.data.Option.sequenceSeq;
-import static fj.data.Option.sequenceSet;
-import static fj.data.Option.sequenceStream;
-import static fj.data.Option.sequenceTrampoline;
-import static fj.data.Option.sequenceValidation;
 import static fj.data.Option.*;
 import static fj.data.Validation.fail;
 import static fj.data.Validation.*;
@@ -66,6 +56,177 @@ public void sequenceValidationTest() {
     assertEquals(some(success("string")), sequence(Validation.<Integer, Option<String>>success(some("string"))));
   }
 
+  @Test
+  public void testBind1() {
+    range(0, 1).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), 0), list.index(0).bind(Option::some));
+        });
+
+  }
+
+  @Test
+  public void testBind2() {
+    range(0, 2).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1)), list.index(0).bind(list.index(1), p2()));
+        });
+  }
+
+  @Test
+  public void testBind3() {
+    range(0, 3).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2)), list.index(0).bind(list.index(1), list.index(2), p3()));
+        });
+
+  }
+
+  @Test
+  public void testBind4() {
+    range(0, 4).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3)), list.index(0).bind(list.index(1), list.index(2), list.index(3), p4()));
+        });
+
+  }
+
+  @Test
+  public void testBind5() {
+    range(0, 5).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), p5()));
+        });
+  }
+
+  @Test
+  public void testBind6() {
+    range(0, 6).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), p6()));
+        });
+  }
+
+  @Test
+  public void testBind7() {
+    range(0, 7).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), p7()));
+        });
+  }
+
+  @Test
+  public void testBind8() {
+    range(0, 8).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8()));
+        });
+  }
+
+  @Test
+  public void testBindProduct2() {
+    range(0, 2).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1)), list.index(0).bindProduct(list.index(1)));
+        });
+  }
+
+  @Test
+  public void testBindProduct3() {
+    range(0, 3).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2)), list.index(0).bindProduct(list.index(1), list.index(2)));
+        });
+
+  }
+
+  @Test
+  public void testBindProduct4() {
+    range(0, 4).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3)));
+        });
+
+  }
+
+  @Test
+  public void testBindProduct5() {
+    range(0, 5).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4)));
+        });
+  }
+
+  @Test
+  public void testBindProduct6() {
+    range(0, 6).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5)));
+        });
+  }
+
+  @Test
+  public void testBindProduct7() {
+    range(0, 7).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6)));
+        });
+  }
+
+  @Test
+  public void testBindProduct8() {
+    range(0, 8).map(i -> arrayList(Option.<Integer>none(), some(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7)));
+        });
+  }
+
+
   @Test
   public void testSequenceEitherLeft() {
     assertEquals(left(none()), sequenceEitherLeft(none()));

From fc85ee1ede0d15b64d12f4d0ec12d5ecc79ed0f8 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Fri, 24 Jul 2020 16:27:38 -0400
Subject: [PATCH 271/336] Fixes #403. Add fj.data.Option.sequence*,
 fj.data.Option.traverse.*; add sequenceEither, traverseEither as aliases for
 sequenceEitherRight, sequenceEitherLeft.

---
 core/src/main/java/fj/data/Option.java     | 24 +++++++++++++++++++
 core/src/test/java/fj/data/OptionTest.java | 27 ++++++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index 655463b7..b6876c63 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -392,6 +392,18 @@ public final <B> Option<B> sequence(final Option<B> o) {
     return bind(c);
   }
 
+  /**
+   * Sequence the given option and collect the output on the right side of an either.
+   *
+   * @param option the given option
+   * @param <B>    the type of the right value
+   * @param <L>    the type of the left value
+   * @return the either
+   */
+  public static final <L, B> Either<L, Option<B>> sequenceEither(final Option<Either<L, B>> option) {
+    return option.traverseEitherRight(identity());
+  }
+
   /**
    * Sequence the given option and collect the output on the left side of an either.
    *
@@ -529,6 +541,18 @@ public static final <E, B> Validation<E, Option<B>> sequenceValidation(final Opt
     return option.traverseValidation(identity());
   }
 
+  /**
+   * Traverse this option with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public final <L, B> Either<L, Option<B>> traverseEither(final F<A, Either<L, B>> f) {
+    return traverseEitherRight(f);
+  }
+
   /**
    * Traverse this option with the given function and collect the output on the left side of an either.
    *
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index d028d4f6..da5ef065 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -13,6 +13,19 @@
 import static fj.data.List.*;
 import static fj.data.Option.iif;
 import static fj.data.Option.sequence;
+import static fj.data.Option.sequenceEither;
+import static fj.data.Option.sequenceEitherLeft;
+import static fj.data.Option.sequenceEitherRight;
+import static fj.data.Option.sequenceF;
+import static fj.data.Option.sequenceIO;
+import static fj.data.Option.sequenceList;
+import static fj.data.Option.sequenceOption;
+import static fj.data.Option.sequenceP1;
+import static fj.data.Option.sequenceSeq;
+import static fj.data.Option.sequenceSet;
+import static fj.data.Option.sequenceStream;
+import static fj.data.Option.sequenceTrampoline;
+import static fj.data.Option.sequenceValidation;
 import static fj.data.Option.*;
 import static fj.data.Validation.fail;
 import static fj.data.Validation.*;
@@ -226,6 +239,12 @@ public void testBindProduct8() {
         });
   }
 
+  @Test
+  public void testSequenceEither() {
+    assertEquals(right(none()), sequenceEither(none()));
+    assertEquals(right(some("zero")), sequenceEither(some(right("zero"))));
+    assertEquals(left("zero"), sequenceEither(some(left("zero"))));
+  }
 
   @Test
   public void testSequenceEitherLeft() {
@@ -311,6 +330,14 @@ public void testSequenceValidation() {
     assertEquals(Validation.success(some(0)), sequenceValidation(some(Validation.success(0))));
   }
 
+  @Test
+  public void testTraverseEither() {
+    assertEquals(right(none()), none().traverseEither(constant(right(0))));
+    assertEquals(right(some(0)), some("zero").traverseEither(constant(right(0))));
+    assertEquals(right(none()), none().traverseEither(constant(left(0))));
+    assertEquals(left(0), some("zero").traverseEither(constant(left(0))));
+  }
+
   @Test
   public void testTraverseEitherLeft() {
     assertEquals(left(none()), none().traverseEitherLeft(constant(left(0))));

From bf3fed02f7ae94107155ed93e271e9f621b0be2a Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Fri, 24 Jul 2020 12:26:28 -0400
Subject: [PATCH 272/336] Fixes #406. Several fj.data.Validation.accumulate
 functions construct unexpected or incorrect failures; add to ValidationTest.

---
 core/src/main/java/fj/data/Validation.java    |  26 +-
 .../src/test/java/fj/data/ValidationTest.java | 245 +++++++++++++++++-
 2 files changed, 242 insertions(+), 29 deletions(-)

diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 2afb91f3..e99d64a1 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -738,20 +738,14 @@ public final <B> Validation<List<E>, B> accumulate(F<T, B> f) {
     }
 
 
-    public final <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C> f) {
-        List<E> list = List.nil();
-        if (isFail()) {
-            list = list.cons(fail());
-        }
-        if (v2.isFail()) {
-            list = list.cons(v2.fail());
-        }
-        if (!list.isEmpty()) {
-            return fail(list);
-        } else {
-            return success(f.f(success(), v2.success()));
-        }
+  public final <B, C> Validation<List<E>, C> accumulate(Validation<E, B> v2, F2<T, B, C> f) {
+    List<E> list = fails(list(this, v2));
+    if (!list.isEmpty()) {
+      return fail(list);
+    } else {
+      return success(f.f(success(), v2.success()));
     }
+  }
 
 
 
@@ -784,7 +778,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
 
 
     public final <B, C, D, $E, $F, G> Validation<List<E>, G> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, F6<T, B, C, D, $E, $F, G> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
@@ -793,7 +787,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
     }
 
     public final <B, C, D, $E, $F, G, H> Validation<List<E>, H> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, F7<T, B, C, D, $E, $F, G, H> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6, v7));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
@@ -802,7 +796,7 @@ public final <B, C, D> Validation<List<E>, D> accumulate(Validation<E, B> v2, Va
     }
 
     public final <B, C, D, $E, $F, G, H, I> Validation<List<E>, I> accumulate(Validation<E, B> v2, Validation<E, C> v3, Validation<E, D> v4, Validation<E, $E> v5, Validation<E, $F> v6, Validation<E, G> v7, Validation<E, H> v8, F8<T, B, C, D, $E, $F, G, H, I> f) {
-        List<E> list = fails(list(this, v2, v3, v4, v5));
+        List<E> list = fails(list(this, v2, v3, v4, v5, v6, v7, v8));
         if (!list.isEmpty()) {
             return fail(list);
         } else {
diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
index 0f1f3216..0df2deb9 100644
--- a/core/src/test/java/fj/data/ValidationTest.java
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -1,14 +1,16 @@
 package fj.data;
 
+import fj.*;
 import fj.control.Trampoline;
 import org.junit.Test;
 
 import java.io.IOException;
 
-import static fj.Function.constant;
+import static fj.Function.*;
 import static fj.Ord.*;
-import static fj.P.p;
+import static fj.P.*;
 import static fj.data.Either.*;
+import static fj.data.List.*;
 import static fj.data.Option.*;
 import static fj.data.Validation.sequenceEitherLeft;
 import static fj.data.Validation.sequenceEitherRight;
@@ -27,6 +29,223 @@
 
 public class ValidationTest {
 
+  @Test
+  public void testAccumulateSemigroup2() {
+    range(0, 2).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1), p2()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1), uncurryF2(p2())));
+        });
+  }
+
+  @Test
+  public void testAccumulateSemigroup3() {
+    range(0, 3).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list ->
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), p3()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), uncurryF3(p3())));
+        });
+
+  }
+
+  @Test
+  public void testAccumulateSemigroup4() {
+    range(0, 4).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list ->
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), p4()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), uncurryF4(p4())));
+        });
+
+  }
+
+  @Test
+  public void testAccumulateSemigroup5() {
+    range(0, 5).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list ->
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), p5()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), uncurryF5(p5())));
+        });
+  }
+
+  @Test
+  public void testAccumulateSemigroup6() {
+    range(0, 6).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list ->
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), p6()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), uncurryF6(p6())));
+        });
+  }
+
+  @Test
+  public void testAccumulateSemigroup7() {
+    range(0, 7).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> 
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), p7()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), uncurryF7(p7())));
+        });
+  }
+
+  @Test
+  public void testAccumulateSemigroup8() {
+    range(0, 8).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list ->
+            accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7)));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8()));
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), uncurryF8(P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8())));
+        });
+  }
+
+  @Test
+  public void testAccumulate0() {
+    range(0, 1).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), 0), list.index(0).accumulate());
+        });
+  }
+
+  @Test
+  public void testAccumulate1() {
+    range(0, 1).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), 0), list.index(0).accumulate(identity()));
+        });
+
+  }
+
+  @Test
+  public void testAccumulate2() {
+    range(0, 2).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(list.index(1), P::p));
+        });
+  }
+
+  @Test
+  public void testAccumulate3() {
+    range(0, 3).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(list.index(1), list.index(2), P::p));
+        });
+
+  }
+
+  @Test
+  public void testAccumulate4() {
+    range(0, 4).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), P::p));
+        });
+
+  }
+
+  @Test
+  public void testAccumulate5() {
+    range(0, 5).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), P::p));
+        });
+  }
+
+  @Test
+  public void testAccumulate6() {
+    range(0, 6).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), P::p));
+        });
+  }
+
+  @Test
+  public void testAccumulate7() {
+    range(0, 7).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), P::p));
+        });
+  }
+
+  @Test
+  public void testAccumulate8() {
+    range(0, 8).map(i -> List.<Validation<List<String>, Integer>>arrayList(fail(arrayList(String.valueOf(i))), success(i)))
+        .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
+            list.map(List::single) :
+            accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
+        .forEach(list -> {
+          assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P::p));
+        });
+  }
+
+  @Test
+  public void testMap() {
+    assertEquals(Validation.<String, Integer>fail("zero"), Validation.<String, String>fail("zero").map(constant(0)));
+    assertEquals(Validation.<String, Integer>success(0), Validation.<String, String>success("zero").map(constant(0)));
+    assertEquals(Validation.<String, Integer>fail("zero"), Validation.<String, String>fail("zero").map(constant(0)));
+    assertEquals(Validation.<String, Integer>success(0), Validation.<String, String>success("zero").map(constant(0)));
+  }
+
+  @Test
+  public void testBind() {
+    assertEquals(Validation.<String, Integer>fail("zero"), Validation.<String, String>fail("zero").bind(constant(Validation.<String, Integer>fail("zero"))));
+    assertEquals(Validation.<String, Integer>fail("zero"), Validation.<String, String>success("zero").bind(constant(Validation.<String, Integer>fail("zero"))));
+    assertEquals(Validation.<String, Integer>fail("zero"), Validation.<String, String>fail("zero").bind(constant(Validation.<String, Integer>success(0))));
+    assertEquals(Validation.<String, Integer>success(0), Validation.<String, String>success("zero").bind(constant(Validation.<String, Integer>success(0))));
+  }
+
   @Test
   public void testSequenceEitherLeft() {
     assertEquals(left(fail("zero")), sequenceEitherLeft(fail("zero")));
@@ -55,10 +274,10 @@ public void testSequenceIO() throws IOException {
 
   @Test
   public void testSequenceList() {
-    assertEquals(List.single(fail("zero")), sequenceList(fail("zero")));
-    assertEquals(List.nil(), sequenceList(success(List.nil())));
-    assertEquals(List.single(success("zero")), sequenceList(success(List.single("zero"))));
-    assertEquals(List.arrayList(success("zero"), success("one")), sequenceList(success(List.arrayList("zero", "one"))));
+    assertEquals(single(fail("zero")), sequenceList(fail("zero")));
+    assertEquals(nil(), sequenceList(success(nil())));
+    assertEquals(single(success("zero")), sequenceList(success(single("zero"))));
+    assertEquals(arrayList(success("zero"), success("one")), sequenceList(success(arrayList("zero", "one"))));
   }
 
   @Test
@@ -87,7 +306,7 @@ public void testSequenceSet() {
     assertEquals(Set.single(validationOrd(stringOrd, intOrd), fail("zero")), sequenceSet(stringOrd, intOrd, fail("zero")));
     assertEquals(Set.empty(validationOrd(stringOrd, intOrd)), sequenceSet(stringOrd, intOrd, success(Set.empty(intOrd))));
     assertEquals(Set.single(validationOrd(intOrd, stringOrd), success("zero")), sequenceSet(intOrd, stringOrd, success(Set.single(stringOrd, "zero"))));
-    assertEquals(Set.arraySet(validationOrd(intOrd, stringOrd), success("zero"), success("one")), sequenceSet(intOrd, stringOrd, Validation.success(Set.arraySet(stringOrd, "zero", "one"))));
+    assertEquals(Set.arraySet(validationOrd(intOrd, stringOrd), success("zero"), success("one")), sequenceSet(intOrd, stringOrd, success(Set.arraySet(stringOrd, "zero", "one"))));
   }
 
   @Test
@@ -141,12 +360,12 @@ public void testTraverseIO() throws IOException {
 
   @Test
   public void testTraverseList() {
-    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.nil())));
-    assertEquals(List.nil(), success("zero").traverseList(constant(List.nil())));
-    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.single(0))));
-    assertEquals(List.single(success(0)), success("zero").traverseList(constant(List.single(0))));
-    assertEquals(List.single(fail("zero")), fail("zero").traverseList(constant(List.arrayList(0, 1))));
-    assertEquals(List.arrayList(success(0), success(1)), success("zero").traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(single(fail("zero")), fail("zero").traverseList(constant(nil())));
+    assertEquals(nil(), success("zero").traverseList(constant(nil())));
+    assertEquals(single(fail("zero")), fail("zero").traverseList(constant(single(0))));
+    assertEquals(single(success(0)), success("zero").traverseList(constant(single(0))));
+    assertEquals(single(fail("zero")), fail("zero").traverseList(constant(arrayList(0, 1))));
+    assertEquals(arrayList(success(0), success(1)), success("zero").traverseList(constant(arrayList(0, 1))));
   }
 
   @Test

From 4377adb82a2013d1faee7eac4c0f25821936ed43 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Fri, 24 Jul 2020 16:37:05 -0400
Subject: [PATCH 273/336] Fixes #407. Add fj.data.Seq.bind(F<A, Seq<B>> f).

---
 core/src/main/java/fj/data/Seq.java     | 25 ++++++++++++++++---------
 core/src/test/java/fj/data/SeqTest.java | 17 ++++++++++++++---
 2 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index abd20162..1ded05eb 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -1,20 +1,15 @@
 package fj.data;
 
 import fj.*;
+import fj.data.List.Buffer;
+import fj.data.fingertrees.*;
+
+import java.util.*;
 
 import static fj.Bottom.error;
 import static fj.Monoid.intAdditionMonoid;
 import static fj.data.fingertrees.FingerTree.measured;
 
-import fj.data.List.Buffer;
-import fj.data.fingertrees.FingerTree;
-import fj.data.fingertrees.MakeTree;
-import fj.data.fingertrees.Measured;
-
-import java.util.AbstractList;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
 /**
  * Provides an immutable finite sequence, implemented as a finger tree. This structure gives O(1) access to
  * the head and tail, as well as O(log n) random access and concatenation of sequences.
@@ -396,4 +391,16 @@ public <B> Seq<B> map(F<A, B> f) {
         return new Seq<>(ftree.map(f, Seq.elemMeasured()));
     }
 
+  /**
+   * Bind the given function across this seq.
+   *
+   * @param f   the given function
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public <B> Seq<B> bind(final F<A, Seq<B>> f) {
+    return foldRight(
+        (element, accumulator) -> f.f(element).append(accumulator),
+        empty());
+  }
 }
diff --git a/core/src/test/java/fj/data/SeqTest.java b/core/src/test/java/fj/data/SeqTest.java
index a7c85175..b19cb7d4 100644
--- a/core/src/test/java/fj/data/SeqTest.java
+++ b/core/src/test/java/fj/data/SeqTest.java
@@ -3,11 +3,10 @@
 import fj.P2;
 import org.junit.Test;
 
+import static fj.Function.constant;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /**
  * Created by MarkPerry on 16/01/2015.
@@ -46,4 +45,16 @@ public void test() {
         assertThat(p2._2(), is(Seq.empty()));
     }
 
+  @Test
+  public void testBind() {
+    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.empty())));
+    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.single(0))));
+    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.empty(), Seq.single("zero").bind(constant(Seq.empty())));
+    assertEquals(Seq.single(0), Seq.single("zero").bind(constant(Seq.single(0))));
+    assertEquals(Seq.arraySeq(0, 1), Seq.single("zero").bind(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.empty(), Seq.arraySeq("zero", "one").bind(constant(Seq.empty())));
+    assertEquals(Seq.arraySeq(0, 0), Seq.arraySeq("zero", "one").bind(constant(Seq.single(0))));
+    assertEquals(Seq.arraySeq(0, 1, 0, 1), Seq.arraySeq("zero", "one").bind(constant(Seq.arraySeq(0, 1))));
+  }
 }

From 671b9d25e8d5a1db25252a889de06467b0696468 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Fri, 24 Jul 2020 17:05:29 -0400
Subject: [PATCH 274/336] Fixes #408. Add fj.data.List.sequence* function,
 fj.data.List.traverse* functions.

---
 core/src/main/java/fj/data/List.java     | 413 ++++++++++++++++++-----
 core/src/test/java/fj/data/ListTest.java | 218 +++++++++++-
 2 files changed, 535 insertions(+), 96 deletions(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index e0e12877..422d246b 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -1,54 +1,30 @@
 package fj.data;
 
-import static fj.Bottom.error;
+import fj.*;
+import fj.control.Trampoline;
+import fj.control.parallel.*;
+import fj.data.optic.Optional;
+import fj.data.optic.*;
+import fj.data.vector.V2;
+import fj.function.Effect1;
 
-import fj.Equal;
-import fj.F2Functions;
-import fj.Hash;
-import fj.Monoid;
-import fj.Ord;
-import fj.Ordering;
-import fj.P;
-import fj.P1;
-import fj.Semigroup;
-import fj.Show;
-import fj.Unit;
-import fj.P2;
-import fj.F0;
-import fj.F;
-import fj.F2;
-import fj.Function;
+import java.lang.Class;
+import java.util.*;
 
+import static fj.Bottom.error;
 import static fj.Function.*;
-import static fj.P.p;
-import static fj.P.p2;
+import static fj.Ord.intOrd;
+import static fj.Ordering.GT;
+import static fj.P.*;
 import static fj.Unit.unit;
 import static fj.data.Array.mkArray;
+import static fj.data.Either.*;
 import static fj.data.List.Buffer.*;
-import static fj.data.Option.none;
-import static fj.data.Option.some;
+import static fj.data.Option.*;
 import static fj.data.optic.Optional.optional;
 import static fj.data.optic.Prism.prism;
 import static fj.data.vector.V.v;
 import static fj.function.Booleans.not;
-import static fj.Ordering.GT;
-import static fj.Ord.intOrd;
-
-
-import fj.control.Trampoline;
-import fj.control.parallel.Promise;
-import fj.control.parallel.Strategy;
-import fj.data.optic.Optional;
-import fj.data.optic.PTraversal;
-import fj.data.optic.Prism;
-import fj.data.optic.Traversal;
-import fj.data.vector.V2;
-import fj.function.Effect1;
-
-import java.util.AbstractCollection;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
 
 /**
  * Provides an in-memory, immutable, singly linked list.
@@ -604,61 +580,315 @@ public final <B> List<B> sequence(final List<B> bs) {
     return bind(c);
   }
 
-    /**
-     * Traverses through the List with the given function
-     *
-     * @param f The function that produces Option value
-     * @return  none if applying f returns none to any element of the list or f mapped list in some .
-     */
-    public final <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
-        return foldRight(
-                (a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),
-                some(List.nil())
-        );
-    }
+  /**
+   * Sequence the given list and collect the output on the right side of an either.
+   *
+   * @param list the given list
+   * @param <B>  the type of the right value
+   * @param <L>  the type of the left value
+   * @return the either
+   */
+  public static final <L, B> Either<L, List<B>> sequenceEither(final List<Either<L, B>> list) {
+    return list.traverseEither(identity());
+  }
 
-    /**
-     * Traverse through the List with given function.
-     *
-     * @param f The function that produces Either value.
-     * @return  error in left or f mapped list in right.
-     */
-    public final <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {
-        return foldRight(
-                (a, acc) -> f.f(a).right().bind(e -> acc.right().map(es -> es.cons(e))),
-                Either.right(List.nil())
-        );
-    }
+  /**
+   * Sequence the given list and collect the output on the left side of an either.
+   *
+   * @param list the given list
+   * @param <R>  the type of the right value
+   * @param <B>  the type of the left value
+   * @return the either
+   */
+  public static final <R, B> Either<List<B>, R> sequenceEitherLeft(final List<Either<B, R>> list) {
+    return list.traverseEitherLeft(identity());
+  }
 
-    public final <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
-        return foldRight(
-                (a, acc) -> f.f(a).bind(s -> acc.map(ss -> ss.cons(s))),
-                Stream.nil()
-        );
-    }
+  /**
+   * Sequence the given list and collect the output on the right side of an either.
+   *
+   * @param list the given list
+   * @param <B>  the type of the right value
+   * @param <L>  the type of the left value
+   * @return the either
+   */
+  public static final <L, B> Either<L, List<B>> sequenceEitherRight(final List<Either<L, B>> list) {
+    return list.traverseEitherRight(identity());
+  }
 
-    public final <B> P1<List<B>> traverseP1(final F<A, P1<B>> f){
-        return foldRight(
-                (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-                p(List.nil())
-        );
-    }
+  /**
+   * Sequence the given list and collect the output as a function.
+   *
+   * @param list the given list
+   * @param <C>  the type of the input value
+   * @param <B>  the type of the output value
+   * @return the either
+   */
+  public static final <C, B> F<C, List<B>> sequenceF(final List<F<C, B>> list) {
+    return list.traverseF(identity());
+  }
 
-    public final <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
-        return this.foldRight(
-                (a, acc) -> IOFunctions.bind(f.f(a), b -> IOFunctions.map(acc, bs -> bs.cons(b))),
-                IOFunctions.unit(List.nil())
-        );
-    }
+  /**
+   * Sequence the given list and collect the output as an IO.
+   *
+   * @param list the given list
+   * @param <B>  the type of the IO value
+   * @return the IO
+   */
+  public static final <B> IO<List<B>> sequenceIO(final List<IO<B>> list) {
+    return list.traverseIO(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as an list.
+   *
+   * @param list the given list
+   * @param <B>  the type of the list value
+   * @return the list
+   */
+  public static final <B> List<List<B>> sequenceList(final List<List<B>> list) {
+    return list.traverseList(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as an list.
+   *
+   * @param list the given list
+   * @param <B>  the type of the list value
+   * @return the list
+   */
+  public static final <B> Option<List<B>> sequenceOption(final List<Option<B>> list) {
+    return list.traverseOption(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a P1.
+   *
+   * @param list the given list
+   * @param <B>  the type of the P1 value
+   * @return the P1
+   */
+  public static final <B> P1<List<B>> sequenceP1(final List<P1<B>> list) {
+    return list.traverseP1(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a seq.
+   *
+   * @param list the given list
+   * @param <B>  the type of the seq value
+   * @return the seq
+   */
+  public static final <B> Seq<List<B>> sequenceSeq(final List<Seq<B>> list) {
+    return list.traverseSeq(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord  the given ord
+   * @param list the given list
+   * @param <B>  the type of the set value
+   * @return the either
+   */
+  public static final <B> Set<List<B>> sequenceSet(final Ord<B> ord, final List<Set<B>> list) {
+    return list.traverseSet(ord, identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a stream.
+   *
+   * @param list the given list
+   * @param <B>  the type of the stream value
+   * @return the stream
+   */
+  public static final <B> Stream<List<B>> sequenceStream(final List<Stream<B>> list) {
+    return list.traverseStream(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a trampoline.
+   *
+   * @param list the given trampoline
+   * @param <B>  the type of the stream value
+   * @return the stream
+   */
+  public static final <B> Trampoline<List<B>> sequenceTrampoline(final List<Trampoline<B>> list) {
+    return list.traverseTrampoline(identity());
+  }
+
+  /**
+   * Sequence the given list and collect the output as a validation; use the given semigroup to reduce the errors.
+   *
+   * @param semigroup the given semigroup
+   * @param list      the given list
+   * @param <E>       the type of the failure value
+   * @param <B>       the type of the success value
+   * @return the validation
+   */
+  public static final <E, B> Validation<E, List<B>> sequenceValidation(final Semigroup<E> semigroup, final List<Validation<E, B>> list) {
+    return list.traverseValidation(semigroup, identity());
+  }
+
+  /**
+   * Traverse through the List with given function.
+   *
+   * @param f The function that produces Either value.
+   * @return error in left or f mapped list in right.
+   */
+  public final <B, E> Either<E, List<B>> traverseEither(final F<A, Either<E, B>> f) {
+    return foldRight(
+        (a, acc) -> f.f(a).right().bind(e -> acc.right().map(es -> es.cons(e))),
+        Either.right(List.nil())
+    );
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output on the left side of an either.
+   *
+   * @param f   the given function
+   * @param <R> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public final <R, B> Either<List<B>, R> traverseEitherLeft(final F<A, Either<B, R>> f) {
+    return foldRight(
+        (element, either) -> f.f(element).left().bind(elementInner -> either.left().map(list -> list.cons(elementInner))),
+        left(nil()));
+  }
 
+  /**
+   * Traverse this list with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public final <L, B> Either<L, List<B>> traverseEitherRight(final F<A, Either<L, B>> f) {
+    return foldRight(
+        (element, either) -> f.f(element).right().bind(elementInner -> either.right().map(list -> list.cons(elementInner))),
+        right(nil()));
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a function.
+   *
+   * @param f   the given function
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the function
+   */
   public final <C, B> F<C, List<B>> traverseF(F<A, F<C, B>> f) {
     return this.foldRight(
         (a, acc) -> Function.bind(acc,
             (bs) -> Function.compose(bs::cons, f.f(a))),
         constant(List.nil())
-        );
+    );
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as an IO.
+   *
+   * @param f   the given function
+   * @param <B> the type of the IO value
+   * @return the IO
+   */
+  public final <B> IO<List<B>> traverseIO(F<A, IO<B>> f) {
+    return this.foldRight(
+        (a, acc) -> IOFunctions.bind(f.f(a), b -> IOFunctions.map(acc, bs -> bs.cons(b))),
+        IOFunctions.unit(List.nil())
+    );
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a list.
+   *
+   * @param f   the given function
+   * @param <B> the type of the list value
+   * @return the list
+   */
+  public final <B> List<List<B>> traverseList(final F<A, List<B>> f) {
+    return foldRight(
+        (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
+        single(List.nil()));
   }
 
+  /**
+   * Traverses through the List with the given function
+   *
+   * @param f The function that produces Option value
+   * @return none if applying f returns none to any element of the list or f mapped list in some .
+   */
+  public final <B> Option<List<B>> traverseOption(final F<A, Option<B>> f) {
+    return foldRight(
+        (a, obs) -> f.f(a).bind(o -> obs.map(os -> os.cons(o))),
+        some(List.nil())
+    );
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a p1.
+   *
+   * @param f   the given function
+   * @param <B> the type of the p1 value
+   * @return the p1
+   */
+  public final <B> P1<List<B>> traverseP1(final F<A, P1<B>> f) {
+    return foldRight(
+        (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
+        p(List.nil())
+    );
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a seq.
+   *
+   * @param f   the given function
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public final <B> Seq<List<B>> traverseSeq(final F<A, Seq<B>> f) {
+    return foldRight(
+        (element, seq) -> f.f(element).bind(elementInner -> seq.map(list -> list.cons(elementInner))),
+        Seq.single(nil()));
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord the given ord
+   * @param f   the given function
+   * @param <B> the type of the set value
+   * @return the set
+   */
+  public final <B> Set<List<B>> traverseSet(final Ord<B> ord, final F<A, Set<B>> f) {
+    final Ord<List<B>> listOption = Ord.listOrd(ord);
+    return foldRight(
+        (element, set) -> f.f(element).bind(listOption, elementInner -> set.map(listOption, list -> list.cons(elementInner))),
+        Set.single(listOption, nil()));
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a stream.
+   *
+   * @param f   the given function
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public final <B> Stream<List<B>> traverseStream(final F<A, Stream<B>> f) {
+    return foldRight(
+        (a, acc) -> f.f(a).bind(s -> acc.map(ss -> ss.cons(s))),
+        Stream.single(nil()));
+  }
+
+  /**
+   * Traverse this list with the given function and collect the output as a trampoline.
+   *
+   * @param f   the given function
+   * @param <B> the type of the trampoline value
+   * @return the trampoline
+   */
   public final <B> Trampoline<List<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
     return foldRight(
         (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
@@ -671,12 +901,15 @@ public final <B> Promise<List<B>> traversePromise(final F<A, Promise<B>> f) {
         Promise.promise(Strategy.idStrategy(), p(List.nil())));
   }
 
-  public final <B> List<List<B>> traverseList(final F<A, List<B>> f) {
-    return foldRight(
-        (a, acc) -> f.f(a).bind(b -> acc.map(bs -> bs.cons(b))),
-        single(List.nil()));
-  }
-
+  /**
+   * Traverse this list with the given function and collect the output as a validation; use the given semigroup to reduce the errors.
+   *
+   * @param s   the given semigroup
+   * @param f   the given function
+   * @param <E> the type of the failure value
+   * @param <B> the type of the success value
+   * @return the validation
+   */
   public final <E, B> Validation<E, List<B>> traverseValidation(Semigroup<E> s, final F<A, Validation<E, B>> f) {
     return Validation.sequence(s, map(f));
   }
@@ -1474,7 +1707,7 @@ public final A maximum(final Ord<A> o) {
   public final Option<A> maximumOption(final Ord<A> o) {
     return NonEmptyList.fromList(this).map(nel -> nel.maximum(o));
   }
-  
+
   /**
    * Returns the minimum element in this list according to the given ordering.
    *
@@ -1484,7 +1717,7 @@ public final Option<A> maximumOption(final Ord<A> o) {
   public final A minimum(final Ord<A> o) {
     return foldLeft1(o::min);
   }
-  
+
   /**
    * Returns the minimum element in this list according to the given ordering.
    *
diff --git a/core/src/test/java/fj/data/ListTest.java b/core/src/test/java/fj/data/ListTest.java
index 3b720fe6..ca7d0f22 100644
--- a/core/src/test/java/fj/data/ListTest.java
+++ b/core/src/test/java/fj/data/ListTest.java
@@ -1,16 +1,36 @@
 package fj.data;
 
-import fj.Equal;
-import fj.P2;
+import fj.*;
+import fj.control.Trampoline;
 import org.junit.Test;
 
+import java.io.IOException;
 import java.util.Arrays;
 
+import static fj.Function.constant;
+import static fj.Ord.*;
+import static fj.P.*;
+import static fj.Semigroup.listSemigroup;
+import static fj.data.Either.*;
+import static fj.data.List.sequenceEither;
+import static fj.data.List.sequenceEitherLeft;
+import static fj.data.List.sequenceEitherRight;
+import static fj.data.List.sequenceF;
+import static fj.data.List.sequenceIO;
+import static fj.data.List.sequenceList;
+import static fj.data.List.sequenceOption;
+import static fj.data.List.sequenceP1;
+import static fj.data.List.sequenceSeq;
+import static fj.data.List.sequenceSet;
+import static fj.data.List.sequenceStream;
+import static fj.data.List.sequenceTrampoline;
+import static fj.data.List.sequenceValidation;
+import static fj.data.List.*;
+import static fj.data.Option.*;
+import static fj.data.Validation.fail;
+import static fj.data.Validation.*;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /**
  * Created by MarkPerry on 16/01/2015.
@@ -91,4 +111,190 @@ public void array() {
         assertThat(List.range(1, max + 1).array(Integer[].class), equalTo(ints));
     }
 
+  @Test
+  public void testSequenceEither() {
+    assertEquals(right(nil()), sequenceEither(nil()));
+    assertEquals(right(single("zero")), sequenceEither(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEither(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherLeft() {
+    assertEquals(left(nil()), sequenceEitherLeft(nil()));
+    assertEquals(left(single("zero")), sequenceEitherLeft(single(left("zero"))));
+    assertEquals(right("zero"), sequenceEitherLeft(single(right("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherRight() {
+    assertEquals(right(nil()), sequenceEitherRight(nil()));
+    assertEquals(right(single("zero")), sequenceEitherRight(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEitherRight(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceF() {
+    assertEquals(constant(nil()).f(1), sequenceF(nil()).f(1));
+    assertEquals(constant(single("zero")).f(1), sequenceF(single(constant("zero"))).f(1));
+  }
+
+  @Test
+  public void testSequenceIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(nil())).run(), sequenceIO(nil()).run());
+    assertEquals(IOFunctions.lazy(constant(single("zero"))).run(), sequenceIO(single(IOFunctions.lazy(constant("zero")))).run());
+  }
+
+  @Test
+  public void testSequenceList() {
+    assertEquals(single(nil()), sequenceList(nil()));
+    assertEquals(List.nil(), sequenceList(single(nil())));
+    assertEquals(single(single("zero")), sequenceList(single(single("zero"))));
+    assertEquals(List.arrayList(single("zero"), single("one")), sequenceList(single(arrayList("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceOption() {
+    assertEquals(some(nil()), sequenceOption(nil()));
+    assertEquals(none(), sequenceOption(single(none())));
+    assertEquals(some(single("zero")), sequenceOption(single(some("zero"))));
+  }
+
+  @Test
+  public void testSequenceP1() {
+    assertEquals(p(nil()), sequenceP1(nil()));
+    assertEquals(p(single("zero")), sequenceP1(single(p("zero"))));
+  }
+
+  @Test
+  public void testSequenceSeq() {
+    assertEquals(Seq.single(nil()), sequenceSeq(nil()));
+    assertEquals(Seq.empty(), sequenceSeq(single(Seq.empty())));
+    assertEquals(Seq.single(single("zero")), sequenceSeq(single(Seq.single("zero"))));
+    assertEquals(Seq.arraySeq(single("zero"), single("one")), sequenceSeq(single(Seq.arraySeq("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceSet() {
+    assertEquals(Set.arraySet(listOrd(stringOrd), nil()), sequenceSet(stringOrd, nil()));
+    assertEquals(Set.empty(listOrd(stringOrd)), sequenceSet(stringOrd, single(Set.empty(stringOrd))));
+    assertEquals(Set.arraySet(listOrd(stringOrd), single("zero")), sequenceSet(stringOrd, single(Set.single(stringOrd, "zero"))));
+    assertEquals(Set.arraySet(listOrd(stringOrd), single("zero"), single("one")), sequenceSet(stringOrd, single(Set.arraySet(stringOrd, "zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceStream() {
+    assertEquals(Stream.single(nil()), sequenceStream(nil()));
+    assertEquals(Stream.nil(), sequenceStream(single(Stream.nil())));
+    assertEquals(Stream.single(single("zero")), sequenceStream(single(Stream.single("zero"))));
+    assertEquals(Stream.arrayStream(single("zero"), single("one")), sequenceStream(single(Stream.arrayStream("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceTrampoline() {
+    assertEquals(Trampoline.pure(nil()).run(), sequenceTrampoline(nil()).run());
+    assertEquals(Trampoline.pure(single(0)).run(), sequenceTrampoline(single(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testSequenceValidation() {
+    assertEquals(Validation.success(nil()), sequenceValidation(listSemigroup(), nil()));
+    assertEquals(Validation.fail(single(0)), sequenceValidation(listSemigroup(), single(Validation.fail(single(0)))));
+    assertEquals(Validation.success(single(0)), sequenceValidation(listSemigroup(), single(Validation.success(0))));
+  }
+
+  @Test
+  public void testTraverseEitherLeft() {
+    assertEquals(left(nil()), nil().traverseEitherLeft(constant(left(0))));
+    assertEquals(left(single(0)), single("zero").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(nil()), nil().traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), single("zero").traverseEitherLeft(constant(right(0))));
+  }
+
+  @Test
+  public void testTraverseEitherRight() {
+    assertEquals(right(nil()), nil().traverseEitherRight(constant(right(0))));
+    assertEquals(right(single(0)), single("zero").traverseEitherRight(constant(right(0))));
+    assertEquals(right(nil()), nil().traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), single("zero").traverseEitherRight(constant(left(0))));
+  }
+
+  @Test
+  public void testTraverseF() {
+    assertEquals(constant(nil()).f(1), nil().traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(single(0)).f(1), single("zero").traverseF(constant(constant(0))).f(1));
+  }
+
+  @Test
+  public void testTraverseIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(nil())).run(), nil().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(single(0))).run(), single("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseList() {
+    assertEquals(single(nil()), nil().traverseList(constant(List.nil())));
+    assertEquals(List.nil(), single("zero").traverseList(constant(List.nil())));
+    assertEquals(single(nil()), nil().traverseList(constant(single(0))));
+    assertEquals(single(single(0)), single("zero").traverseList(constant(single(0))));
+    assertEquals(single(nil()), nil().traverseList(constant(List.arrayList(0, 1))));
+    assertEquals(List.arrayList(single(0), single(1)), single("zero").traverseList(constant(List.arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseOption() {
+    assertEquals(some(nil()), nil().traverseOption(constant(none())));
+    assertEquals(none(), single("zero").traverseOption(constant(none())));
+    assertEquals(some(nil()), nil().traverseOption(constant(some(0))));
+    assertEquals(some(single(0)), single("zero").traverseOption(constant(some(0))));
+  }
+
+  @Test
+  public void testTraverseP1() {
+    assertEquals(p(nil()), nil().traverseP1(constant(p(0))));
+    assertEquals(p(single(0)), single("zero").traverseP1(constant(p(0))));
+  }
+
+  @Test
+  public void testTraverseSeq() {
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.empty(), single("zero").traverseSeq(constant(Seq.empty())));
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(single(0)), single("zero").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(Seq.arraySeq(0, 1))));
+    assertEquals(Seq.arraySeq(single(0), single(1)), single("zero").traverseSeq(constant(Seq.arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testTraverseSet() {
+    assertEquals(Set.arraySet(listOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(listOrd(intOrd)), single("zero").traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.single(listOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(listOrd(intOrd), single(0)), single("zero").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(listOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(listOrd(intOrd), single(0), single(1)), single("zero").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+  }
+
+  @Test
+  public void testTraverseStream() {
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), single("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(single(0)), single("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(single(0), single(1)), single("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseTrampoline() {
+    assertEquals(Trampoline.pure(nil()).run(), nil().traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(single(0)).run(), single("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testTraverseValidation() {
+    assertEquals(success(nil()), nil().traverseValidation(listSemigroup(), constant(Validation.fail(single(0)))));
+    assertEquals(fail(single(0)), single("zero").traverseValidation(listSemigroup(), constant(Validation.fail(single(0)))));
+    assertEquals(success(nil()), nil().traverseValidation(listSemigroup(), constant(Validation.success(0))));
+    assertEquals(success(single(0)), single("zero").traverseValidation(listSemigroup(), constant(Validation.success(0))));
+  }
 }

From 24779066804769cd93a7e4cc4236b44836e43074 Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Fri, 24 Jul 2020 23:39:07 -0400
Subject: [PATCH 275/336] Fixes #412. Add fj.data.Seq.sequence*,
 fj.data.Seq.traverse* functions.

---
 core/src/main/java/fj/Ord.java          |  51 ++--
 core/src/main/java/fj/data/Seq.java     | 361 ++++++++++++++++++++++++
 core/src/test/java/fj/data/SeqTest.java | 251 +++++++++++++++-
 3 files changed, 638 insertions(+), 25 deletions(-)

diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index 0a778f4d..eef729c4 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -1,23 +1,11 @@
 package fj;
 
-import fj.data.Array;
-import fj.data.Either;
-import fj.data.List;
-import fj.data.Natural;
-import fj.data.NonEmptyList;
-import fj.data.Option;
-import fj.data.Set;
-import fj.data.Stream;
-import fj.data.Validation;
-
-import java.math.BigDecimal;
-import java.math.BigInteger;
+import fj.data.*;
+
+import java.math.*;
 import java.util.Comparator;
 
-import static fj.Function.apply;
-import static fj.Function.compose;
-import static fj.Function.curry;
-import static fj.Semigroup.semigroup;
+import static fj.Function.*;
 import static fj.Semigroup.semigroupDef;
 
 /**
@@ -541,6 +529,37 @@ public static <A> Ord<List<A>> listOrd(final Ord<A> oa) {
     });
   }
 
+  /**
+   * Return a seq ord using the given value ord.
+   *
+   * @param ord the given value ord
+   * @param <A> the type of the seq value
+   * @return the seq ord
+   */
+  public static <A> Ord<Seq<A>> seqOrd(final Ord<A> ord) {
+    return ordDef((l1, l2) -> {
+      Seq<A> x1 = l1;
+      Seq<A> x2 = l2;
+
+      while (x1.isNotEmpty() && x2.isNotEmpty()) {
+        final Ordering o = ord.compare(x1.head(), x2.head());
+        if (o == Ordering.LT || o == Ordering.GT) {
+          return o;
+        }
+        x1 = x1.tail();
+        x2 = x2.tail();
+      }
+
+      if (x1.isEmpty() && x2.isEmpty()) {
+        return Ordering.EQ;
+      } else if (x1.isEmpty()) {
+        return Ordering.LT;
+      } else {
+        return Ordering.GT;
+      }
+    });
+  }
+
   /**
    * An order instance for the {@link NonEmptyList} type.
    *
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index 1ded05eb..3bcb7033 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -1,13 +1,19 @@
 package fj.data;
 
 import fj.*;
+import fj.control.Trampoline;
 import fj.data.List.Buffer;
 import fj.data.fingertrees.*;
 
 import java.util.*;
 
 import static fj.Bottom.error;
+import static fj.Function.*;
 import static fj.Monoid.intAdditionMonoid;
+import static fj.P.p;
+import static fj.data.Either.*;
+import static fj.data.Option.some;
+import static fj.data.Validation.success;
 import static fj.data.fingertrees.FingerTree.measured;
 
 /**
@@ -403,4 +409,359 @@ public <B> Seq<B> bind(final F<A, Seq<B>> f) {
         (element, accumulator) -> f.f(element).append(accumulator),
         empty());
   }
+
+  /**
+   * Sequence the given seq and collect the output on the right side of an either.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the right value
+   * @param <L> the type of the left value
+   * @return the either
+   */
+  public static <L, B> Either<L, Seq<B>> sequenceEither(final Seq<Either<L, B>> seq) {
+    return seq.traverseEither(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output on the left side of an either.
+   *
+   * @param seq the given seq
+   * @param <R> the type of the right value
+   * @param <B> the type of the left value
+   * @return the either
+   */
+  public static <R, B> Either<Seq<B>, R> sequenceEitherLeft(final Seq<Either<B, R>> seq) {
+    return seq.traverseEitherLeft(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output on the right side of an either.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the right value
+   * @param <L> the type of the left value
+   * @return the either
+   */
+  public static <L, B> Either<L, Seq<B>> sequenceEitherRight(final Seq<Either<L, B>> seq) {
+    return seq.traverseEitherRight(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a function.
+   *
+   * @param seq the given seq
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the either
+   */
+  public static <C, B> F<C, Seq<B>> sequenceF(final Seq<F<C, B>> seq) {
+    return seq.traverseF(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as an IO.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the IO value
+   * @return the IO
+   */
+  public static <B> IO<Seq<B>> sequenceIO(final Seq<IO<B>> seq) {
+    return seq.traverseIO(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a list.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the seq value
+   * @return the list
+   */
+  public static <B> List<Seq<B>> sequenceList(final Seq<List<B>> seq) {
+    return seq.traverseList(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as an seq.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public static <B> Option<Seq<B>> sequenceOption(final Seq<Option<B>> seq) {
+    return seq.traverseOption(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a P1.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the P1 value
+   * @return the P1
+   */
+  public static <B> P1<Seq<B>> sequenceP1(final Seq<P1<B>> seq) {
+    return seq.traverseP1(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a seq.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public static <B> Seq<Seq<B>> sequenceSeq(final Seq<Seq<B>> seq) {
+    return seq.traverseSeq(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord the given ord
+   * @param seq the given seq
+   * @param <B> the type of the set value
+   * @return the either
+   */
+  public static <B> Set<Seq<B>> sequenceSet(final Ord<B> ord, final Seq<Set<B>> seq) {
+    return seq.traverseSet(ord, identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a stream.
+   *
+   * @param seq the given seq
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public static <B> Stream<Seq<B>> sequenceStream(final Seq<Stream<B>> seq) {
+    return seq.traverseStream(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a trampoline.
+   *
+   * @param seq the given trampoline
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public static <B> Trampoline<Seq<B>> sequenceTrampoline(final Seq<Trampoline<B>> seq) {
+    return seq.traverseTrampoline(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a validation.
+   *
+   * @param seq the given seq
+   * @param <E> the type of the failure value
+   * @param <B> the type of the success value
+   * @return the validation
+   */
+  public static <E, B> Validation<E, Seq<B>> sequenceValidation(final Seq<Validation<E, B>> seq) {
+    return seq.traverseValidation(identity());
+  }
+
+  /**
+   * Sequence the given seq and collect the output as a validation; use the given semigroup to reduce the errors.
+   *
+   * @param semigroup the given semigroup
+   * @param seq       the given seq
+   * @param <E>       the type of the failure value
+   * @param <B>       the type of the success value
+   * @return the validation
+   */
+  public static <E, B> Validation<E, Seq<B>> sequenceValidation(final Semigroup<E> semigroup, final Seq<Validation<E, B>> seq) {
+    return seq.traverseValidation(semigroup, identity());
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <B, L> Either<L, Seq<B>> traverseEither(final F<A, Either<L, B>> f) {
+    return traverseEitherRight(f);
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output on the left side of an either.
+   *
+   * @param f   the given function
+   * @param <R> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <R, B> Either<Seq<B>, R> traverseEitherLeft(final F<A, Either<B, R>> f) {
+    return foldRight(
+        (element, either) -> f.f(element).left().bind(elementInner -> either.left().map(seq -> seq.cons(elementInner))),
+        left(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <L, B> Either<L, Seq<B>> traverseEitherRight(final F<A, Either<L, B>> f) {
+    return foldRight(
+        (element, either) -> f.f(element).right().bind(elementInner -> either.right().map(seq -> seq.cons(elementInner))),
+        right(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a function.
+   *
+   * @param f   the given function
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the function
+   */
+  public <C, B> F<C, Seq<B>> traverseF(final F<A, F<C, B>> f) {
+    return foldRight(
+        (element, fInner) -> Function.bind(f.f(element), elementInner -> andThen(fInner, seq -> seq.cons(elementInner))),
+        constant(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as an IO.
+   *
+   * @param f   the given function
+   * @param <B> the type of the IO value
+   * @return the IO
+   */
+  public <B> IO<Seq<B>> traverseIO(final F<A, IO<B>> f) {
+    return foldRight(
+        (element, io) -> IOFunctions.bind(f.f(element), elementInner -> IOFunctions.map(io, seq -> seq.cons(elementInner))),
+        IOFunctions.unit(empty())
+    );
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a list.
+   *
+   * @param f   the given function
+   * @param <B> the type of the list value
+   * @return the list
+   */
+  public <B> List<Seq<B>> traverseList(final F<A, List<B>> f) {
+    return foldRight(
+        (element, list) -> f.f(element).bind(elementInner -> list.map(seq -> seq.cons(elementInner))),
+        List.single(empty()));
+  }
+
+  /**
+   * Traverses through the Seq with the given function
+   *
+   * @param f The function that produces Option value
+   * @return none if applying f returns none to any element of the seq or f mapped seq in some .
+   */
+  public <B> Option<Seq<B>> traverseOption(final F<A, Option<B>> f) {
+    return foldRight(
+        (element, option) -> f.f(element).bind(elementInner -> option.map(seq -> seq.cons(elementInner))),
+        some(empty())
+    );
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a p1.
+   *
+   * @param f   the given function
+   * @param <B> the type of the p1 value
+   * @return the p1
+   */
+  public <B> P1<Seq<B>> traverseP1(final F<A, P1<B>> f) {
+    return foldRight(
+        (element, p1) -> f.f(element).bind(elementInner -> p1.map(seq -> seq.cons(elementInner))),
+        p(empty())
+    );
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a seq.
+   *
+   * @param f   the given function
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public <B> Seq<Seq<B>> traverseSeq(final F<A, Seq<B>> f) {
+    return foldRight(
+        (element, seq) -> f.f(element).bind(elementInner -> seq.map(seqInner -> seqInner.cons(elementInner))),
+        single(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord the given ord
+   * @param f   the given function
+   * @param <B> the type of the set value
+   * @return the set
+   */
+  public <B> Set<Seq<B>> traverseSet(final Ord<B> ord, final F<A, Set<B>> f) {
+    final Ord<Seq<B>> seqOrd = Ord.seqOrd(ord);
+    return foldRight(
+        (element, set) -> f.f(element).bind(seqOrd, elementInner -> set.map(seqOrd, seq -> seq.cons(elementInner))),
+        Set.single(seqOrd, empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a stream.
+   *
+   * @param f   the given function
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public <B> Stream<Seq<B>> traverseStream(final F<A, Stream<B>> f) {
+    return foldRight(
+        (element, stream) -> f.f(element).bind(elementInner -> stream.map(seq -> seq.cons(elementInner))),
+        Stream.single(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a trampoline.
+   *
+   * @param f   the given function
+   * @param <B> the type of the trampoline value
+   * @return the trampoline
+   */
+  public <B> Trampoline<Seq<B>> traverseTrampoline(final F<A, Trampoline<B>> f) {
+    return foldRight(
+        (element, trampoline) -> f.f(element).bind(elementInner -> trampoline.map(seq -> seq.cons(elementInner))),
+        Trampoline.pure(empty()));
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a validation.
+   *
+   * @param f   the given function
+   * @param <E> the type of the failure value
+   * @param <B> the type of the success value
+   * @return the validation
+   */
+  public <E, B> Validation<E, Seq<B>> traverseValidation(final F<A, Validation<E, B>> f) {
+    return foldRight(
+        (element, validation) -> f.f(element).bind(elementInner -> validation.map(seq -> seq.cons(elementInner))),
+        success(empty())
+    );
+  }
+
+  /**
+   * Traverse this seq with the given function and collect the output as a validation; use the given semigroup to reduce the errors.
+   *
+   * @param semigroup the given semigroup
+   * @param f         the given function
+   * @param <E>       the type of the failure value
+   * @param <B>       the type of the success value
+   * @return the validation
+   */
+  public <E, B> Validation<E, Seq<B>> traverseValidation(final Semigroup<E> semigroup, final F<A, Validation<E, B>> f) {
+    return foldRight(
+        (element, validation) -> f.f(element).map(Seq::single).accumulate(semigroup, validation, Seq::append),
+        success(empty())
+    );
+  }
 }
diff --git a/core/src/test/java/fj/data/SeqTest.java b/core/src/test/java/fj/data/SeqTest.java
index b19cb7d4..0b62db00 100644
--- a/core/src/test/java/fj/data/SeqTest.java
+++ b/core/src/test/java/fj/data/SeqTest.java
@@ -1,9 +1,34 @@
 package fj.data;
 
 import fj.P2;
+import fj.control.Trampoline;
 import org.junit.Test;
 
+import java.io.IOException;
+
 import static fj.Function.constant;
+import static fj.Ord.*;
+import static fj.P.p;
+import static fj.Semigroup.listSemigroup;
+import static fj.data.Either.*;
+import static fj.data.List.arrayList;
+import static fj.data.Option.*;
+import static fj.data.Seq.sequenceEither;
+import static fj.data.Seq.sequenceEitherLeft;
+import static fj.data.Seq.sequenceEitherRight;
+import static fj.data.Seq.sequenceF;
+import static fj.data.Seq.sequenceIO;
+import static fj.data.Seq.sequenceList;
+import static fj.data.Seq.sequenceOption;
+import static fj.data.Seq.sequenceP1;
+import static fj.data.Seq.sequenceSeq;
+import static fj.data.Seq.sequenceSet;
+import static fj.data.Seq.sequenceStream;
+import static fj.data.Seq.sequenceTrampoline;
+import static fj.data.Seq.sequenceValidation;
+import static fj.data.Seq.*;
+import static fj.data.Validation.fail;
+import static fj.data.Validation.*;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
@@ -47,14 +72,222 @@ public void test() {
 
   @Test
   public void testBind() {
-    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.empty())));
-    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.single(0))));
-    assertEquals(Seq.empty(), Seq.empty().bind(constant(Seq.arraySeq(0, 1))));
-    assertEquals(Seq.empty(), Seq.single("zero").bind(constant(Seq.empty())));
-    assertEquals(Seq.single(0), Seq.single("zero").bind(constant(Seq.single(0))));
-    assertEquals(Seq.arraySeq(0, 1), Seq.single("zero").bind(constant(Seq.arraySeq(0, 1))));
-    assertEquals(Seq.empty(), Seq.arraySeq("zero", "one").bind(constant(Seq.empty())));
-    assertEquals(Seq.arraySeq(0, 0), Seq.arraySeq("zero", "one").bind(constant(Seq.single(0))));
-    assertEquals(Seq.arraySeq(0, 1, 0, 1), Seq.arraySeq("zero", "one").bind(constant(Seq.arraySeq(0, 1))));
+    assertEquals(empty(), empty().bind(constant(empty())));
+    assertEquals(empty(), empty().bind(constant(single(0))));
+    assertEquals(empty(), empty().bind(constant(arraySeq(0, 1))));
+    assertEquals(empty(), single("zero").bind(constant(empty())));
+    assertEquals(single(0), single("zero").bind(constant(single(0))));
+    assertEquals(arraySeq(0, 1), single("zero").bind(constant(arraySeq(0, 1))));
+    assertEquals(empty(), arraySeq("zero", "one").bind(constant(empty())));
+    assertEquals(arraySeq(0, 0), arraySeq("zero", "one").bind(constant(single(0))));
+    assertEquals(arraySeq(0, 1, 0, 1), arraySeq("zero", "one").bind(constant(arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testSequenceEither() {
+    assertEquals(right(empty()), sequenceEither(empty()));
+    assertEquals(right(single("zero")), sequenceEither(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEither(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherLeft() {
+    assertEquals(left(empty()), sequenceEitherLeft(empty()));
+    assertEquals(left(single("zero")), sequenceEitherLeft(single(left("zero"))));
+    assertEquals(right("zero"), sequenceEitherLeft(single(right("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherRight() {
+    assertEquals(right(empty()), sequenceEitherRight(empty()));
+    assertEquals(right(single("zero")), sequenceEitherRight(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEitherRight(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceF() {
+    assertEquals(constant(empty()).f(1), sequenceF(empty()).f(1));
+    assertEquals(constant(single("zero")).f(1), sequenceF(single(constant("zero"))).f(1));
+  }
+
+  @Test
+  public void testSequenceIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(empty())).run(), sequenceIO(empty()).run());
+    assertEquals(IOFunctions.lazy(constant(single("zero"))).run(), sequenceIO(single(IOFunctions.lazy(constant("zero")))).run());
+  }
+
+  @Test
+  public void testSequenceList() {
+    assertEquals(List.single(empty()), sequenceList(empty()));
+    assertEquals(List.nil(), sequenceList(single(List.nil())));
+    assertEquals(List.single(single("zero")), sequenceList(single(List.single("zero"))));
+    assertEquals(arrayList(single("zero"), single("one")), sequenceList(single(arrayList("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceOption() {
+    assertEquals(some(empty()), sequenceOption(empty()));
+    assertEquals(none(), sequenceOption(single(none())));
+    assertEquals(some(single("zero")), sequenceOption(single(some("zero"))));
+  }
+
+  @Test
+  public void testSequenceP1() {
+    assertEquals(p(empty()), sequenceP1(empty()));
+    assertEquals(p(single("zero")), sequenceP1(single(p("zero"))));
+  }
+
+  @Test
+  public void testSequenceSeq() {
+    assertEquals(single(empty()), sequenceSeq(empty()));
+    assertEquals(empty(), sequenceSeq(single(empty())));
+    assertEquals(single(single("zero")), sequenceSeq(single(single("zero"))));
+    assertEquals(arraySeq(single("zero"), single("one")), sequenceSeq(single(arraySeq("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceSet() {
+    assertEquals(Set.arraySet(seqOrd(stringOrd), empty()), sequenceSet(stringOrd, empty()));
+    assertEquals(Set.empty(seqOrd(stringOrd)), sequenceSet(stringOrd, single(Set.empty(stringOrd))));
+    assertEquals(Set.arraySet(seqOrd(stringOrd), single("zero")), sequenceSet(stringOrd, single(Set.single(stringOrd, "zero"))));
+    assertEquals(Set.arraySet(seqOrd(stringOrd), single("zero"), single("one")), sequenceSet(stringOrd, single(Set.arraySet(stringOrd, "zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceStream() {
+    assertEquals(Stream.single(empty()), sequenceStream(empty()));
+    assertEquals(Stream.nil(), sequenceStream(single(Stream.nil())));
+    assertEquals(Stream.single(single("zero")), sequenceStream(single(Stream.single("zero"))));
+    assertEquals(Stream.arrayStream(single("zero"), single("one")), sequenceStream(single(Stream.arrayStream("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceTrampoline() {
+    assertEquals(Trampoline.pure(empty()).run(), sequenceTrampoline(empty()).run());
+    assertEquals(Trampoline.pure(single(0)).run(), sequenceTrampoline(single(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testSequenceValidation() {
+    assertEquals(success(empty()), sequenceValidation(empty()));
+    assertEquals(fail(single(0)), sequenceValidation(single(fail(single(0)))));
+    assertEquals(success(single(0)), sequenceValidation(single(success(0))));
+  }
+
+  @Test
+  public void testSequenceValidationSemigroup() {
+    assertEquals(success(empty()), sequenceValidation(listSemigroup(), empty()));
+    assertEquals(fail(List.single(0)), sequenceValidation(listSemigroup(), single(fail(List.single(0)))));
+    assertEquals(success(single(0)), sequenceValidation(listSemigroup(), single(success(0))));
+  }
+
+  @Test
+  public void testTraverseEitherLeft() {
+    assertEquals(left(empty()), empty().traverseEitherLeft(constant(left(0))));
+    assertEquals(left(single(0)), single("zero").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(empty()), empty().traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), single("zero").traverseEitherLeft(constant(right(0))));
+  }
+
+  @Test
+  public void testTraverseEitherRight() {
+    assertEquals(right(empty()), empty().traverseEitherRight(constant(right(0))));
+    assertEquals(right(single(0)), single("zero").traverseEitherRight(constant(right(0))));
+    assertEquals(right(empty()), empty().traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), single("zero").traverseEitherRight(constant(left(0))));
+  }
+
+  @Test
+  public void testTraverseF() {
+    assertEquals(constant(empty()).f(1), empty().traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(single(0)).f(1), single("zero").traverseF(constant(constant(0))).f(1));
+  }
+
+  @Test
+  public void testTraverseIO() throws IOException {
+    assertEquals(IOFunctions.lazy(constant(empty())).run(), empty().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(single(0))).run(), single("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseList() {
+    assertEquals(List.single(empty()), empty().traverseList(constant(List.nil())));
+    assertEquals(List.nil(), single("zero").traverseList(constant(List.nil())));
+    assertEquals(List.single(empty()), empty().traverseList(constant(List.single(0))));
+    assertEquals(List.single(single(0)), single("zero").traverseList(constant(List.single(0))));
+    assertEquals(List.single(empty()), empty().traverseList(constant(arrayList(0, 1))));
+    assertEquals(arrayList(single(0), single(1)), single("zero").traverseList(constant(arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseOption() {
+    assertEquals(some(empty()), empty().traverseOption(constant(none())));
+    assertEquals(none(), single("zero").traverseOption(constant(none())));
+    assertEquals(some(empty()), empty().traverseOption(constant(some(0))));
+    assertEquals(some(single(0)), single("zero").traverseOption(constant(some(0))));
+  }
+
+  @Test
+  public void testTraverseP1() {
+    assertEquals(p(empty()), empty().traverseP1(constant(p(0))));
+    assertEquals(p(single(0)), single("zero").traverseP1(constant(p(0))));
+  }
+
+  @Test
+  public void testTraverseSeq() {
+    assertEquals(single(empty()), empty().traverseSeq(constant(empty())));
+    assertEquals(empty(), single("zero").traverseSeq(constant(empty())));
+    assertEquals(single(empty()), empty().traverseSeq(constant(single(0))));
+    assertEquals(single(single(0)), single("zero").traverseSeq(constant(single(0))));
+    assertEquals(single(empty()), empty().traverseSeq(constant(arraySeq(0, 1))));
+    assertEquals(arraySeq(single(0), single(1)), single("zero").traverseSeq(constant(arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testTraverseSet() {
+    assertEquals(Set.arraySet(seqOrd(intOrd), empty()), empty().traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(seqOrd(intOrd)), single("zero").traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.single(seqOrd(intOrd), empty()), empty().traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(seqOrd(intOrd), single(0)), single("zero").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(seqOrd(intOrd), empty()), empty().traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(seqOrd(intOrd), single(0), single(1)), single("zero").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+  }
+
+  @Test
+  public void testTraverseStream() {
+    assertEquals(Stream.single(empty()), empty().traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), single("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.single(empty()), empty().traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(single(0)), single("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(empty()), empty().traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(single(0), single(1)), single("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseTrampoline() {
+    assertEquals(Trampoline.pure(empty()).run(), empty().traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(single(0)).run(), single("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testTraverseValidation() {
+    assertEquals(success(empty()), empty().traverseValidation(constant(fail(single(0)))));
+    assertEquals(fail(single(0)), single("zero").traverseValidation(constant(fail(single(0)))));
+    assertEquals(success(empty()), empty().traverseValidation(constant(success(0))));
+    assertEquals(success(single(0)), single("zero").traverseValidation(constant(success(0))));
+
+    assertEquals(success(arraySeq(0, 2, 4, 6, 8)), arraySeq(0, 2, 4, 6, 8).traverseValidation(i -> condition(i% 2 == 0, List.single(i), i)));
+    assertEquals(fail(List.single(1)), arraySeq(0, 1, 2, 3, 4, 5, 6, 7, 8, 9).traverseValidation(i -> condition(i% 2 == 0, List.single(i), i)));
+  }
+
+  @Test
+  public void testTraverseValidationSemigroup() {
+    assertEquals(success(empty()), empty().traverseValidation(listSemigroup(), constant(fail(List.single(0)))));
+    assertEquals(fail(List.single(0)), single("zero").traverseValidation(listSemigroup(), constant(fail(List.single(0)))));
+    assertEquals(success(empty()), empty().traverseValidation(listSemigroup(), constant(success(0))));
+    assertEquals(success(single(0)), single("zero").traverseValidation(listSemigroup(), constant(success(0))));
+
+    assertEquals(success(arraySeq(0, 2, 4, 6, 8)), arraySeq(0, 2, 4, 6, 8).traverseValidation(listSemigroup(),i -> condition(i% 2 == 0, List.single(i), i)));
+    assertEquals(fail(arrayList(1, 3, 5, 7, 9)), arraySeq(0, 1, 2, 3, 4, 5, 6, 7, 8, 9).traverseValidation(listSemigroup(),i -> condition(i% 2 == 0, List.single(i), i)));
   }
 }

From 3bce5e0b885b87d94396d7f1cd6fb889958c0e8c Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Wed, 29 Jul 2020 14:17:37 -0400
Subject: [PATCH 276/336] Fixes #414. Add fj.data.Either.leftMap, rightMap.

Also adds LeftProjection.traverseP1, RightProjection.valueE(String), RightProjection.orValue.
---
 core/src/main/java/fj/data/Either.java     | 101 +++-
 core/src/test/java/fj/data/EitherTest.java | 653 +++++++++++++++++++++
 2 files changed, 739 insertions(+), 15 deletions(-)
 create mode 100644 core/src/test/java/fj/data/EitherTest.java

diff --git a/core/src/main/java/fj/data/Either.java b/core/src/main/java/fj/data/Either.java
index a9a746a9..c132ec49 100644
--- a/core/src/main/java/fj/data/Either.java
+++ b/core/src/main/java/fj/data/Either.java
@@ -1,27 +1,16 @@
 package fj.data;
 
-import fj.Equal;
-import fj.F;
-import fj.F0;
-import fj.Function;
-import fj.Hash;
-import fj.P1;
-import fj.Show;
-import fj.Unit;
+import fj.*;
 import fj.function.Effect1;
 
-import java.util.Collection;
-import java.util.Iterator;
+import java.util.*;
 
 import static fj.Bottom.error;
-import static fj.Function.compose;
-import static fj.Function.identity;
+import static fj.Function.*;
 import static fj.P.p;
 import static fj.Unit.unit;
 import static fj.data.Array.mkArray;
-import static fj.data.List.cons_;
-import static fj.data.List.list;
-import static fj.data.List.single;
+import static fj.data.List.*;
 import static fj.data.Option.some;
 
 /**
@@ -321,6 +310,19 @@ public <C> IO<Either<C, B>> traverseIO(final F<A, IO<C>> f) {
                   IOFunctions.unit(Either.right(e.right().value()));
       }
 
+    /**
+     * Traverse this left with the given function and collect the output as a p1.
+     *
+     * @param f   the given function
+     * @param <C> the type of the p1 value
+     * @return the p1
+     */
+    public <C> P1<Either<C, B>> traverseP1(final F<A, P1<C>> f) {
+      return e.isLeft() ?
+          f.f(value()).map(left_()) :
+          p(right(e.right().value()));
+    }
+
     /**
      * Returns <code>None</code> if this projection has no value or if the given predicate
      * <code>p</code> does not hold for the value, otherwise, returns a right in <code>Some</code>.
@@ -464,6 +466,16 @@ public Either<A, B> either() {
       return e;
     }
 
+    /**
+     * Returns the value of this projection or fails with the given error message.
+     *
+     * @param err The error message to fail with.
+     * @return The value of this projection
+     */
+    public B valueE(final String err) {
+      return valueE(p(err));
+    }
+
     /**
      * Returns the value of this projection or fails with the given error message.
      *
@@ -487,6 +499,16 @@ public B value() {
       return valueE(p("right.value on Left"));
     }
 
+    /**
+     * The value of this projection or the given argument.
+     *
+     * @param a The value to return if this projection has no value.
+     * @return The value of this projection or the given argument.
+     */
+    public B orValue(final B a) {
+      return e.isRight() ? value() : a;
+    }
+
     /**
      * The value of this projection or the given argument.
      *
@@ -586,12 +608,26 @@ public <C> IO<Either<A, C>> traverseIO(final F<B, IO<C>> f) {
                   IOFunctions.lazy(() -> left(e.left().value()));
       }
 
+    /**
+     * Traverse this right with the given function and collect the output as a p1.
+     *
+     * @param f   the given function
+     * @param <C> the type of the p1 value
+     * @return the p1
+     */
       public <C> P1<Either<A, C>> traverseP1(final F<B, P1<C>> f) {
           return e.isRight() ?
                   f.f(value()).map(right_()) :
                   p(left(e.left().value()));
       }
 
+    /**
+     * Traverse this right with the given function and collect the output as an option.
+     *
+     * @param f the given function
+     * @param <C> the type of the option value
+     * @return the option
+     */
       public <C> Option<Either<A, C>> traverseOption(final F<B, Option<C>> f) {
           return e.isRight() ?
                   f.f(value()).map(right_()) :
@@ -758,6 +794,22 @@ public static <A, B, X> F<Either<A,B>, X> either_(final F<A, X> left, final F<B,
   }
 
   /**
+   * Map the given function across this either's left projection.
+   *
+   * @param f   the given function
+   * @param <X> the type of the function output
+   * @return the either
+   */
+  public final <X> Either<X, B> leftMap(final F<A, X> f) {
+    return left().map(f);
+  }
+
+  /**
+   * Return a function that maps a given function across this either's left projection.
+   *
+   * @param <A> the type of the right value
+   * @param <B> the type of the left value
+   * @param <X> the type of the function output
    * @return A function that maps another function across an either's left projection.
    */
   public static <A, B, X> F<F<A, X>, F<Either<A, B>, Either<X, B>>> leftMap_() {
@@ -765,6 +817,22 @@ public static <A, B, X> F<F<A, X>, F<Either<A, B>, Either<X, B>>> leftMap_() {
   }
 
   /**
+   * Map the given function across this either's right.
+   *
+   * @param f   the given function
+   * @param <X> the type of the function output
+   * @return the either
+   */
+  public final <X> Either<A, X> rightMap(final F<B, X> f) {
+    return right().map(f);
+  }
+
+  /**
+   * Return a function that maps a given function across this either's right projection.
+   *
+   * @param <A> the type of the right value
+   * @param <B> the type of the left value
+   * @param <X> the type of the function output
    * @return A function that maps another function across an either's right projection.
    */
   public static <A, B, X> F<F<B, X>, F<Either<A, B>, Either<A, X>>> rightMap_() {
@@ -796,6 +864,7 @@ public static <A, B> Either<A, B> joinRight(final Either<A, Either<A, B>> e) {
    *
    * @param a The list of values to sequence with the either monad.
    * @return A sequenced value.
+   * @see fj.data.List#sequenceEitherLeft
    */
   public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a) {
     return a.isEmpty() ?
@@ -808,6 +877,8 @@ public static <A, X> Either<List<A>, X> sequenceLeft(final List<Either<A, X>> a)
    *
    * @param a The list of values to sequence with the either monad.
    * @return A sequenced value.
+   * @see fj.data.List#sequenceEither
+   * @see fj.data.List#sequenceEitherRight
    */
   public static <B, X> Either<X, List<B>> sequenceRight(final List<Either<X, B>> a) {
     return a.isEmpty() ?
diff --git a/core/src/test/java/fj/data/EitherTest.java b/core/src/test/java/fj/data/EitherTest.java
new file mode 100644
index 00000000..31a83347
--- /dev/null
+++ b/core/src/test/java/fj/data/EitherTest.java
@@ -0,0 +1,653 @@
+package fj.data;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static fj.Function.constant;
+import static fj.P.p;
+import static fj.Unit.unit;
+import static fj.data.Either.*;
+import static org.junit.Assert.*;
+
+public final class EitherTest {
+
+  public static final class LeftProjectionTest {
+    @Test
+    public void testIterator() {
+      assertEquals(0L, (long) left(0L).left().iterator().next());
+      assertFalse(right(0).left().iterator().hasNext());
+    }
+
+    @Test
+    public void testEither() {
+      assertEquals(left(0), left(0).left().either());
+      assertEquals(right(0), right(0).left().either());
+    }
+
+    @Test
+    public void testValueEString() {
+      assertEquals(0L, (long) left(0L).left().valueE("zero"));
+
+      try {
+        right(0L).left().valueE("zero");
+        fail();
+      } catch (final Error error) {
+        assertEquals("zero", error.getMessage());
+      }
+    }
+
+    @Test
+    public void testValueEF0() {
+      assertEquals(0L, (long) left(0L).left().valueE(() -> "zero"));
+
+      try {
+        right(0L).left().valueE(() -> "zero");
+        fail();
+      } catch (final Error error) {
+        assertEquals("zero", error.getMessage());
+      }
+    }
+
+    @Test
+    public void testValue() {
+      assertEquals(0L, (long) left(0L).left().value());
+
+      try {
+        right(0L).left().value();
+        fail();
+      } catch (final Error error) {
+        // pass
+      }
+    }
+
+    @Test
+    public void testOrValue() {
+      assertEquals(0L, (long) left(0L).left().orValue(1L));
+      assertEquals(1L, (long) right(0L).left().orValue(1L));
+    }
+
+    @Test
+    public void testOrValueF0() {
+      assertEquals(0L, (long) left(0L).left().orValue(() -> 1L));
+      assertEquals(1L, (long) right(0L).left().orValue(() -> 1L));
+    }
+
+    @Test
+    public void testOn() {
+      assertEquals(0L, (long) Either.<Long, Long>left(0L).left().on(constant(1L)));
+      assertEquals(1L, (long) Either.<Long, Long>right(0L).left().on(constant(1L)));
+    }
+
+    @Test
+    public void testForeach() {
+      left(0).left().foreach(constant(unit()));
+      right(0).left().foreach(ignore -> {
+        fail();
+        return unit();
+      });
+    }
+
+    @Test
+    public void testForeachDoEffect() {
+      left(0).left().foreachDoEffect(ignore -> {
+      });
+      right(0).left().foreachDoEffect(ignore -> fail());
+    }
+
+    @Test
+    public void testMap() {
+      assertEquals(left(0), left("zero").left().map(constant(0)));
+      assertEquals(right("zero"), right("zero").left().map(constant(0)));
+    }
+
+    @Test
+    public void testBind() {
+      assertEquals(left(0), left("zero").left().bind(constant(left(0))));
+      assertEquals(right("zero"), right("zero").left().bind(constant(left(0))));
+    }
+
+    @Test
+    public void testSequence() {
+      assertEquals(left(0), left("zero").left().sequence(left(0)));
+      assertEquals(right(0), left("zero").left().sequence(right(0)));
+      assertEquals(right("zero"), right("zero").left().sequence(left(0)));
+      assertEquals(right("zero"), right("zero").left().sequence(right("one")));
+    }
+
+    @Test
+    public void testTraverseList() {
+      assertEquals(List.nil(), left("zero").left().traverseList(constant(List.nil())));
+      assertEquals(List.single(left(0)), left("zero").left().traverseList(constant(List.single(0))));
+      assertEquals(List.arrayList(left(0), left(1)), left("zero").left().traverseList(constant(List.arrayList(0, 1))));
+      assertEquals(List.single(right("zero")), right("zero").left().traverseList(constant(List.nil())));
+      assertEquals(List.single(right("zero")), right("zero").left().traverseList(constant(List.single(0))));
+      assertEquals(List.single(right("zero")), right("zero").left().traverseList(constant(List.arrayList(0, 1))));
+    }
+
+    @Test
+    public void testTraverseIO() throws IOException {
+      assertEquals(left(0), left("zero").left().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+      assertEquals(right("zero"), right("zero").left().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    }
+
+    @Test
+    public void testTraverseP1() {
+      assertEquals(p(left(0)), left("zero").left().traverseP1(constant(p(0))));
+      assertEquals(p(right("zero")), right("zero").left().traverseP1(constant(p(0))));
+    }
+
+    @Test
+    public void testFilter() {
+      assertEquals(Option.none(), left(0).left().filter(constant(false)));
+      assertEquals(Option.none(), right(0).left().filter(constant(false)));
+      assertEquals(Option.some(left(0)), left(0).left().filter(constant(true)));
+      assertEquals(Option.none(), right(0).left().filter(constant(true)));
+    }
+
+    @Test
+    public void testApply() {
+      assertEquals(left(1), left("zero").left().apply(left(constant(1))));
+      assertEquals(right("zero"), right("zero").left().apply(left(constant(1))));
+    }
+
+    @Test
+    public void testForAll() {
+      assertFalse(left(0).left().forall(constant(false)));
+      assertTrue(right(0).left().forall(constant(false)));
+      assertTrue(left(0).left().forall(constant(true)));
+      assertTrue(right(0).left().forall(constant(true)));
+    }
+
+    @Test
+    public void testExists() {
+      assertFalse(left(0).left().exists(constant(false)));
+      assertFalse(right(0).left().exists(constant(false)));
+      assertTrue(left(0).left().exists(constant(true)));
+      assertFalse(right(0).left().exists(constant(true)));
+    }
+
+    @Test
+    public void testToList() {
+      assertEquals(List.single(0), left(0).left().toList());
+      assertEquals(List.nil(), right(0).left().toList());
+    }
+
+    @Test
+    public void testToOption() {
+      assertEquals(Option.some(0), left(0).left().toOption());
+      assertEquals(Option.none(), right(0).left().toOption());
+    }
+
+    @Test
+    public void testToArray() {
+      assertEquals(Array.single(0), left(0).left().toArray());
+      assertEquals(Array.empty(), right(0).left().toArray());
+    }
+
+    @Test
+    public void testToStream() {
+      assertEquals(Stream.single(0), left(0).left().toStream());
+      assertEquals(Stream.nil(), right(0).left().toStream());
+    }
+
+    @Test
+    public void testToCollection() {
+      assertEquals(1L, left(0L).left().toCollection().size());
+      assertEquals(0L, (long) left(0L).left().toCollection().iterator().next());
+      assertTrue(right(0).left().toCollection().isEmpty());
+    }
+
+    @Test
+    public void testTraverseOption() {
+      assertEquals(Option.none(), left("zero").left().traverseOption(constant(Option.none())));
+      assertEquals(Option.some(left(0)), left("zero").left().traverseOption(constant(Option.some(0))));
+      assertEquals(Option.some(right("zero")), right("zero").left().traverseOption(constant(Option.none())));
+      assertEquals(Option.some(right("zero")), right("zero").left().traverseOption(constant(Option.some(0))));
+    }
+
+    @Test
+    public void testTraverseStream() {
+      assertEquals(Stream.nil(), left("zero").left().traverseStream(constant(Stream.nil())));
+      assertEquals(Stream.single(left(0)), left("zero").left().traverseStream(constant(Stream.single(0))));
+      assertEquals(Stream.arrayStream(left(0), left(1)), left("zero").left().traverseStream(constant(Stream.arrayStream(0, 1))));
+      assertEquals(Stream.single(right("zero")), right("zero").left().traverseStream(constant(Stream.nil())));
+      assertEquals(Stream.single(right("zero")), right("zero").left().traverseStream(constant(Stream.single(0))));
+      assertEquals(Stream.single(right("zero")), right("zero").left().traverseStream(constant(Stream.arrayStream(0, 1))));
+    }
+  }
+
+  public static final class RightProjectionTest {
+    @Test
+    public void testIterator() {
+      assertEquals(0L, (long) right(0L).right().iterator().next());
+      assertFalse(left(0).right().iterator().hasNext());
+    }
+
+    @Test
+    public void testEither() {
+      assertEquals(right(0), right(0).right().either());
+      assertEquals(left(0), left(0).right().either());
+    }
+
+    @Test
+    public void testValueEString() {
+      assertEquals(0L, (long) right(0L).right().valueE("zero"));
+
+      try {
+        left(0L).right().valueE("zero");
+        fail();
+      } catch (final Error error) {
+        assertEquals("zero", error.getMessage());
+      }
+    }
+
+    @Test
+    public void testValueEF0() {
+      assertEquals(0L, (long) right(0L).right().valueE(() -> "zero"));
+
+      try {
+        left(0L).right().valueE(() -> "zero");
+        fail();
+      } catch (final Error error) {
+        assertEquals("zero", error.getMessage());
+      }
+    }
+
+    @Test
+    public void testValue() {
+      assertEquals(0L, (long) right(0L).right().value());
+
+      try {
+        left(0L).right().value();
+        fail();
+      } catch (final Error error) {
+        // pass
+      }
+    }
+
+    @Test
+    public void testOrValue() {
+      assertEquals(0L, (long) right(0L).right().orValue(1L));
+      assertEquals(1L, (long) left(0L).right().orValue(1L));
+    }
+
+    @Test
+    public void testOrValueF0() {
+      assertEquals(0L, (long) right(0L).right().orValue(() -> 1L));
+      assertEquals(1L, (long) left(0L).right().orValue(() -> 1L));
+    }
+
+    @Test
+    public void testOn() {
+      assertEquals(0L, (long) Either.<Long, Long>right(0L).right().on(constant(1L)));
+      assertEquals(1L, (long) Either.<Long, Long>left(0L).right().on(constant(1L)));
+    }
+
+    @Test
+    public void testForeach() {
+      right(0).right().foreach(constant(unit()));
+      left(0).right().foreach(ignore -> {
+        fail();
+        return unit();
+      });
+    }
+
+    @Test
+    public void testForeachDoEffect() {
+      right(0).right().foreachDoEffect(ignore -> {
+      });
+      left(0).right().foreachDoEffect(ignore -> fail());
+    }
+
+    @Test
+    public void testMap() {
+      assertEquals(right(0), right("zero").right().map(constant(0)));
+      assertEquals(left("zero"), left("zero").right().map(constant(0)));
+    }
+
+    @Test
+    public void testBind() {
+      assertEquals(right(0), right("zero").right().bind(constant(right(0))));
+      assertEquals(left("zero"), left("zero").right().bind(constant(right(0))));
+    }
+
+    @Test
+    public void testSequence() {
+      assertEquals(right(0), right("zero").right().sequence(right(0)));
+      assertEquals(left(0), right("zero").right().sequence(left(0)));
+      assertEquals(left("zero"), left("zero").right().sequence(right(0)));
+      assertEquals(left("zero"), left("zero").right().sequence(left("one")));
+    }
+
+    @Test
+    public void testTraverseList() {
+      assertEquals(List.nil(), right("zero").right().traverseList(constant(List.nil())));
+      assertEquals(List.single(right(0)), right("zero").right().traverseList(constant(List.single(0))));
+      assertEquals(List.arrayList(right(0), right(1)), right("zero").right().traverseList(constant(List.arrayList(0, 1))));
+      assertEquals(List.single(left("zero")), left("zero").right().traverseList(constant(List.nil())));
+      assertEquals(List.single(left("zero")), left("zero").right().traverseList(constant(List.single(0))));
+      assertEquals(List.single(left("zero")), left("zero").right().traverseList(constant(List.arrayList(0, 1))));
+    }
+
+    @Test
+    public void testTraverseIO() throws IOException {
+      assertEquals(right(0), right("zero").right().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+      assertEquals(left("zero"), left("zero").right().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    }
+
+    @Test
+    public void testTraverseP1() {
+      assertEquals(p(right(0)), right("zero").right().traverseP1(constant(p(0))));
+      assertEquals(p(left("zero")), left("zero").right().traverseP1(constant(p(0))));
+    }
+
+    @Test
+    public void testFilter() {
+      assertEquals(Option.none(), right(0).right().filter(constant(false)));
+      assertEquals(Option.none(), left(0).right().filter(constant(false)));
+      assertEquals(Option.some(right(0)), right(0).right().filter(constant(true)));
+      assertEquals(Option.none(), left(0).right().filter(constant(true)));
+    }
+
+    @Test
+    public void testApply() {
+      assertEquals(right(1), right("zero").right().apply(right(constant(1))));
+      assertEquals(left("zero"), left("zero").right().apply(right(constant(1))));
+    }
+
+    @Test
+    public void testForAll() {
+      assertFalse(right(0).right().forall(constant(false)));
+      assertTrue(left(0).right().forall(constant(false)));
+      assertTrue(right(0).right().forall(constant(true)));
+      assertTrue(left(0).right().forall(constant(true)));
+    }
+
+    @Test
+    public void testExists() {
+      assertFalse(right(0).right().exists(constant(false)));
+      assertFalse(left(0).right().exists(constant(false)));
+      assertTrue(right(0).right().exists(constant(true)));
+      assertFalse(left(0).right().exists(constant(true)));
+    }
+
+    @Test
+    public void testToList() {
+      assertEquals(List.single(0), right(0).right().toList());
+      assertEquals(List.nil(), left(0).right().toList());
+    }
+
+    @Test
+    public void testToOption() {
+      assertEquals(Option.some(0), right(0).right().toOption());
+      assertEquals(Option.none(), left(0).right().toOption());
+    }
+
+    @Test
+    public void testToArray() {
+      assertEquals(Array.single(0), right(0).right().toArray());
+      assertEquals(Array.empty(), left(0).right().toArray());
+    }
+
+    @Test
+    public void testToStream() {
+      assertEquals(Stream.single(0), right(0).right().toStream());
+      assertEquals(Stream.nil(), left(0).right().toStream());
+    }
+
+    @Test
+    public void testToCollection() {
+      assertEquals(1L, right(0L).right().toCollection().size());
+      assertEquals(0L, (long) right(0L).right().toCollection().iterator().next());
+      assertTrue(left(0).right().toCollection().isEmpty());
+    }
+
+    @Test
+    public void testTraverseOption() {
+      assertEquals(Option.none(), right("zero").right().traverseOption(constant(Option.none())));
+      assertEquals(Option.some(right(0)), right("zero").right().traverseOption(constant(Option.some(0))));
+      assertEquals(Option.some(left("zero")), left("zero").right().traverseOption(constant(Option.none())));
+      assertEquals(Option.some(left("zero")), left("zero").right().traverseOption(constant(Option.some(0))));
+    }
+
+    @Test
+    public void testTraverseStream() {
+      assertEquals(Stream.nil(), right("zero").right().traverseStream(constant(Stream.nil())));
+      assertEquals(Stream.single(right(0)), right("zero").right().traverseStream(constant(Stream.single(0))));
+      assertEquals(Stream.arrayStream(right(0), right(1)), right("zero").right().traverseStream(constant(Stream.arrayStream(0, 1))));
+      assertEquals(Stream.single(left("zero")), left("zero").right().traverseStream(constant(Stream.nil())));
+      assertEquals(Stream.single(left("zero")), left("zero").right().traverseStream(constant(Stream.single(0))));
+      assertEquals(Stream.single(left("zero")), left("zero").right().traverseStream(constant(Stream.arrayStream(0, 1))));
+    }
+  }
+
+  @Test
+  public void testIsLeft() {
+    assertTrue(left(0).isLeft());
+    assertFalse(right(0).isLeft());
+  }
+
+  @Test
+  public void testIsRight() {
+    assertFalse(left(0).isRight());
+    assertTrue(right(0).isRight());
+  }
+
+  @Test
+  public void testEither() {
+    assertEquals(-1L, (long) left("zero").either(constant(-1L), constant(1L)));
+    assertEquals(1L, (long) right("zero").either(constant(-1L), constant(1L)));
+  }
+
+  @Test
+  public void testBimap() {
+    assertEquals(left(-1), left("zero").bimap(constant(-1), constant(1)));
+    assertEquals(right(1), right("zero").bimap(constant(-1), constant(1)));
+  }
+
+  @Test
+  public void testTestEquals() {
+    assertNotEquals(null, left(0));
+    assertNotEquals(new Object(), left(0));
+    assertNotEquals(left(0), right(0));
+    assertEquals(left(0), left(0));
+
+    assertNotEquals(null, right(0));
+    assertNotEquals(new Object(), right(0));
+    assertEquals(right(0), right(0));
+    assertNotEquals(right(0), left(0));
+  }
+
+  @Test
+  public void testTestHashCode() {
+    assertEquals(left(0).hashCode(), left(0).hashCode());
+    assertEquals(left(0).hashCode(), right(0).hashCode());
+    assertEquals(right(0).hashCode(), left(0).hashCode());
+    assertEquals(right(0).hashCode(), left(0).hashCode());
+  }
+
+  @Test
+  public void testSwap() {
+    assertEquals(right(0), left(0).swap());
+    assertEquals(left(0), right(0).swap());
+  }
+
+  @Test
+  public void testLeft_() {
+    assertEquals(left(0), left_().f(0));
+  }
+
+  @Test
+  public void testRight_() {
+    assertEquals(right(0), right_().f(0));
+  }
+
+  @Test
+  public void testEither_() {
+    assertEquals(-1L, (long) either_(constant(-1L), constant(1L)).f(left("zero")));
+    assertEquals(1L, (long) either_(constant(-1L), constant(1L)).f(right("zero")));
+  }
+
+  @Test
+  public void testLeftMap() {
+    assertEquals(left(0), left("zero").leftMap(constant(0)));
+    assertEquals(right("zero"), right("zero").leftMap(constant(0)));
+  }
+
+  @Test
+  public void testLeftMap_() {
+    assertEquals(left(0), leftMap_().f(constant(0)).f(left("zero")));
+    assertEquals(right("zero"), leftMap_().f(constant(0)).f(right("zero")));
+  }
+
+  @Test
+  public void testRightMap() {
+    assertEquals(left("zero"), left("zero").rightMap(constant(0)));
+    assertEquals(right(0), right("zero").rightMap(constant(0)));
+  }
+
+  @Test
+  public void testRightMap_() {
+    assertEquals(left("zero"), rightMap_().f(constant(0)).f(left("zero")));
+    assertEquals(right(0), rightMap_().f(constant(0)).f(right("zero")));
+  }
+
+  @Test
+  public void testJoinLeft() {
+    assertEquals(left(0), joinLeft(left(left(0))));
+    assertEquals(right(0), joinLeft(left(right(0))));
+    assertEquals(right(left(0)), joinLeft(right(left(0))));
+    assertEquals(right(right(0)), joinLeft(right(right(0))));
+  }
+
+  @Test
+  public void testJoinRight() {
+    assertEquals(left(left(0)), joinRight(left(left(0))));
+    assertEquals(left(right(0)), joinRight(left(right(0))));
+    assertEquals(left(0), joinRight(right(left(0))));
+    assertEquals(right(0), joinRight(right(right(0))));
+  }
+
+  @Test
+  public void testSequenceLeft() {
+    assertEquals(left(List.nil()), sequenceLeft(List.nil()));
+    assertEquals(left(List.single("zero")), sequenceLeft(List.single(left("zero"))));
+    assertEquals(right("zero"), sequenceLeft(List.single(right("zero"))));
+  }
+
+  @Test
+  public void testSequenceRight() {
+    assertEquals(right(List.nil()), sequenceRight(List.nil()));
+    assertEquals(right(List.single("zero")), sequenceRight(List.single(right("zero"))));
+    assertEquals(left("zero"), sequenceRight(List.single(left("zero"))));
+  }
+
+  @Test
+  public void testTraverseListRight() {
+    assertEquals(List.single(left("zero")), left("zero").traverseListRight(constant(List.nil())));
+    assertEquals(List.single(left("zero")), left("zero").traverseListRight(constant(List.single(0))));
+    assertEquals(List.single(left("zero")), left("zero").traverseListRight(constant(List.arrayList(0, 1))));
+    assertEquals(List.nil(), right("zero").traverseListRight(constant(List.nil())));
+    assertEquals(List.single(right(0)), right("zero").traverseListRight(constant(List.single(0))));
+    assertEquals(List.arrayList(right(0), right(1)), right("zero").traverseListRight(constant(List.arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseListLeft() {
+    assertEquals(List.nil(), left("zero").traverseListLeft(constant(List.nil())));
+    assertEquals(List.single(left(0)), left("zero").traverseListLeft(constant(List.single(0))));
+    assertEquals(List.arrayList(left(0), left(1)), left("zero").traverseListLeft(constant(List.arrayList(0, 1))));
+    assertEquals(List.single(right("zero")), right("zero").traverseListLeft(constant(List.nil())));
+    assertEquals(List.single(right("zero")), right("zero").traverseListLeft(constant(List.single(0))));
+    assertEquals(List.single(right("zero")), right("zero").traverseListLeft(constant(List.arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseIORight() throws IOException {
+    assertEquals(left("zero"), left("zero").traverseIORight(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(right(0), right("zero").traverseIORight(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseIOLeft() throws IOException {
+    assertEquals(left(0), left("zero").traverseIOLeft(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(right("zero"), right("zero").traverseIOLeft(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseOptionRight() {
+    assertEquals(Option.some(left("zero")), left("zero").traverseOptionRight(constant(Option.none())));
+    assertEquals(Option.some(left("zero")), left("zero").traverseOptionRight(constant(Option.some(0))));
+    assertEquals(Option.none(), right("zero").traverseOptionRight(constant(Option.none())));
+    assertEquals(Option.some(right(0)), right("zero").traverseOptionRight(constant(Option.some(0))));
+  }
+
+  @Test
+  public void testTraverseOptionLeft() {
+    assertEquals(Option.none(), left("zero").traverseOptionLeft(constant(Option.none())));
+    assertEquals(Option.some(left(0)), left("zero").traverseOptionLeft(constant(Option.some(0))));
+    assertEquals(Option.some(right("zero")), right("zero").traverseOptionLeft(constant(Option.none())));
+    assertEquals(Option.some(right("zero")), right("zero").traverseOptionLeft(constant(Option.some(0))));
+  }
+
+  @Test
+  public void testTraverseStreamRight() {
+    assertEquals(Stream.single(left("zero")), left("zero").traverseStreamRight(constant(Stream.nil())));
+    assertEquals(Stream.single(left("zero")), left("zero").traverseStreamRight(constant(Stream.single(0))));
+    assertEquals(Stream.single(left("zero")), left("zero").traverseStreamRight(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.nil(), right("zero").traverseStreamRight(constant(Stream.nil())));
+    assertEquals(Stream.single(right(0)), right("zero").traverseStreamRight(constant(Stream.single(0))));
+    assertEquals(Stream.arrayStream(right(0), right(1)), right("zero").traverseStreamRight(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseStreamLeft() {
+    assertEquals(Stream.nil(), left("zero").traverseStreamLeft(constant(Stream.nil())));
+    assertEquals(Stream.single(left(0)), left("zero").traverseStreamLeft(constant(Stream.single(0))));
+    assertEquals(Stream.arrayStream(left(0), left(1)), left("zero").traverseStreamLeft(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.single(right("zero")), right("zero").traverseStreamLeft(constant(Stream.nil())));
+    assertEquals(Stream.single(right("zero")), right("zero").traverseStreamLeft(constant(Stream.single(0))));
+    assertEquals(Stream.single(right("zero")), right("zero").traverseStreamLeft(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testReduce() {
+    assertEquals(0L, (long) reduce(left(0L)));
+    assertEquals(0L, (long) reduce(right(0L)));
+  }
+
+  @Test
+  public void testIif() {
+    assertEquals(right(-1), iif(true, () -> -1, () -> 1));
+    assertEquals(left(1), iif(false, () -> -1, () -> 1));
+  }
+
+  @Test
+  public void testLefts() {
+    assertEquals(List.nil(), lefts(List.nil()));
+    assertEquals(List.single(0), lefts(List.single(left(0))));
+    assertEquals(List.nil(), lefts(List.single(right(0))));
+    assertEquals(List.arrayList(0, 1), lefts(List.arrayList(left(0), left(1))));
+    assertEquals(List.single(0), lefts(List.arrayList(left(0), right(1))));
+    assertEquals(List.single(1), lefts(List.arrayList(right(0), left(1))));
+    assertEquals(List.nil(), lefts(List.arrayList(right(0), right(1))));
+  }
+
+  @Test
+  public void testRights() {
+    assertEquals(List.nil(), rights(List.nil()));
+    assertEquals(List.single(0), rights(List.single(right(0))));
+    assertEquals(List.single(0), lefts(List.single(left(0))));
+    assertEquals(List.arrayList(0, 1), rights(List.arrayList(right(0), right(1))));
+    assertEquals(List.single(0), rights(List.arrayList(right(0), left(1))));
+    assertEquals(List.single(1), rights(List.arrayList(left(0), right(1))));
+    assertEquals(List.nil(), rights(List.arrayList(left(0), left(1))));
+  }
+
+  @Test
+  public void testTestToString() {
+    assertNotNull(left(0).toString());
+    assertNotNull(right(0).toString());
+  }
+}
\ No newline at end of file

From 849dc39c6d5e937f9cd650da8e5de5cbf2bf062d Mon Sep 17 00:00:00 2001
From: Drew Taylor <drew.taylor@gtri.gatech.edu>
Date: Thu, 6 Aug 2020 10:35:26 -0400
Subject: [PATCH 277/336] Fixes #417. Add fj.data.State.bind(F<A, State<S,
 B>>).

---
 core/src/main/java/fj/data/State.java     | 18 +++++++++++
 core/src/test/java/fj/data/StateTest.java | 39 +++++++++++++++++++++--
 2 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index f29d55d7..f0156b36 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -111,6 +111,24 @@ public State<S, A> withs(F<S, S> f) {
     return suspended(s -> runF.f(f.f(s)));
   }
 
+  /**
+   * Bind the given function across this state.
+   *
+   * @param f   the given function
+   * @param <B> the type of the output value
+   * @return the state
+   */
+  public <B> State<S, B> bind(F<A, State<S, B>> f) {
+    return flatMap(f);
+  }
+
+  /**
+   * Bind the given function across this state.
+   *
+   * @param f   the given function
+   * @param <B> the type of the output value
+   * @return the state
+   */
   public <B> State<S, B> flatMap(F<A, State<S, B>> f) {
     return suspended(s -> runF.f(s).bind(result -> Trampoline.pure(f.f(result._2()).run(result._1()))));
   }
diff --git a/core/src/test/java/fj/data/StateTest.java b/core/src/test/java/fj/data/StateTest.java
index 9fc8a9fb..37b21030 100644
--- a/core/src/test/java/fj/data/StateTest.java
+++ b/core/src/test/java/fj/data/StateTest.java
@@ -2,14 +2,47 @@
 
 import org.junit.Test;
 
+import static fj.P.p;
+import static org.junit.Assert.assertEquals;
+
 /**
  * Created by MarkPerry on 18/12/2014.
  */
 public class StateTest {
 
-    @Test
-    public void map() {
+  @Test
+  public void testBind() {
+    assertEquals(p(2, "one"), state().run(1));
+    assertEquals(p(3, "two"), state().run(2));
+    assertEquals(p(4, "three"), state().run(3));
+    assertEquals(p(2, "?"), state().bind(state -> State.constant("?")).run(1));
+    assertEquals(p(3, "?"), state().bind(state -> State.constant("?")).run(2));
+    assertEquals(p(4, "?"), state().bind(state -> State.constant("?")).run(3));
+  }
+
+  @Test
+  public void testFlatMap() {
+    assertEquals(p(2, "one"), state().run(1));
+    assertEquals(p(3, "two"), state().run(2));
+    assertEquals(p(4, "three"), state().run(3));
+    assertEquals(p(2, "?"), state().flatMap(state -> State.constant("?")).run(1));
+    assertEquals(p(3, "?"), state().flatMap(state -> State.constant("?")).run(2));
+    assertEquals(p(4, "?"), state().flatMap(state -> State.constant("?")).run(3));
+  }
 
-    }
+  private static final State<Integer, String> state() {
+    return State.<Integer, String>unit(i -> p(i + 1, toLapine(i)));
+  }
 
+  private static String toLapine(
+      final int i) {
+    return i == 1 ?
+        "one" :
+        i == 2 ?
+            "two" :
+            i == 3 ?
+                "three" :
+                i == 4 ?
+                    "four" : "hrair";
+  }
 }

From c427a086d6a06a14074719d2f3c9a011ce7ad14d Mon Sep 17 00:00:00 2001
From: Drew Taylor <drewctaylor@gmail.com>
Date: Thu, 22 Oct 2020 07:07:30 -0400
Subject: [PATCH 278/336] Fixes #424. Add fj.data.Stream.sequence*,
 fj.data.Stream.traverse* functions.

---
 core/src/main/java/fj/data/Stream.java        | 432 +++++++++++++++++-
 .../test/java/fj/data/IOFunctionsTest.java    |   2 +-
 core/src/test/java/fj/data/StreamTest.java    | 237 ++++++++++
 3 files changed, 649 insertions(+), 22 deletions(-)

diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index a523515b..e05e26bf 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -4,6 +4,7 @@
 import fj.F0;
 import fj.F3;
 import fj.Hash;
+import fj.Semigroup;
 import fj.Show;
 import fj.F;
 import fj.F2;
@@ -14,6 +15,7 @@
 import fj.P1;
 import fj.P2;
 import fj.Unit;
+import fj.control.Trampoline;
 import fj.control.parallel.Promise;
 import fj.control.parallel.Strategy;
 import fj.Ordering;
@@ -1094,27 +1096,6 @@ public final Stream<A> takeWhile(final F<A, Boolean> f) {
            Stream.nil();
   }
 
-  /**
-   * Traversable instance of Stream for IO.
-   *
-   * @return traversed value
-   */
-  public final <B> IO<Stream<B>> traverseIO(F<A, IO<B>> f) {
-    return this.foldRight1((a, acc) ->
-            IOFunctions.bind(acc, (Stream<B> bs) ->
-                    IOFunctions.map(f.f(a), bs::cons)), IOFunctions.unit(Stream.nil()));
-
-  }
-
-  /**
-   * Traversable instance of Stream for Option.
-   *
-   * @return traversed value
-   */
-  public final <B> Option<Stream<B>> traverseOption(F<A, Option<B>> f) {
-    return this.foldRight1((a, acc) -> acc.bind(bs -> f.f(a).map(bs::cons)), some(Stream.nil()));
-  }
-
   /**
    * Removes elements from the head of this stream that do not match the given predicate function
    * until an element is found that does match or the stream is exhausted.
@@ -1669,4 +1650,413 @@ public static <A, B> F<F<A, Stream<B>>, F<Stream<A>, Stream<B>>> bind_() {
   public static <A, B> F<F<A, F<P1<B>, B>>, F<B, F<Stream<A>, B>>> foldRight() {
     return curry((f, b, as) -> as.foldRight(f, b));
   }
+
+  /**
+   * Sequence the given stream and collect the output on the right side of an either.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the right value
+   * @param <L>    the type of the left value
+   * @return the either
+   */
+  public static <L, B> Either<L, Stream<B>> sequenceEither(
+      final Stream<Either<L, B>> stream) {
+    return stream.traverseEither(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output on the left side of an either.
+   *
+   * @param stream the given stream
+   * @param <R>    the type of the right value
+   * @param <B>    the type of the left value
+   * @return the either
+   */
+  public static <R, B> Either<Stream<B>, R> sequenceEitherLeft(
+      final Stream<Either<B, R>> stream) {
+    return stream.traverseEitherLeft(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output on the right side of an either.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the right value
+   * @param <L>    the type of the left value
+   * @return the either
+   */
+  public static <L, B> Either<L, Stream<B>> sequenceEitherRight(
+      final Stream<Either<L, B>> stream) {
+    return stream.traverseEitherRight(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a function.
+   *
+   * @param stream the given stream
+   * @param <C>    the type of the input value
+   * @param <B>    the type of the output value
+   * @return the either
+   */
+  public static <C, B> F<C, Stream<B>> sequenceF(
+      final Stream<F<C, B>> stream) {
+    return stream.traverseF(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as an IO.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the IO value
+   * @return the IO
+   */
+  public static <B> IO<Stream<B>> sequenceIO(
+      final Stream<IO<B>> stream) {
+    return stream.traverseIO(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a list.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the list value
+   * @return the list
+   */
+  public static <B> List<Stream<B>> sequenceList(
+      final Stream<List<B>> stream) {
+    return stream.traverseList(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as an stream.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the option value
+   * @return the stream
+   */
+  public static <B> Option<Stream<B>> sequenceOption(
+      final Stream<Option<B>> stream) {
+    return stream.traverseOption(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a P1.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the P1 value
+   * @return the P1
+   */
+  public static <B> P1<Stream<B>> sequenceP1(
+      final Stream<P1<B>> stream) {
+    return stream.traverseP1(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a seq.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the stream value
+   * @return the seq
+   */
+  public static <B> Seq<Stream<B>> sequenceSeq(
+      final Stream<Seq<B>> stream) {
+    return stream.traverseSeq(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord    the given ord
+   * @param stream the given stream
+   * @param <B>    the type of the set value
+   * @return the either
+   */
+  public static <B> Set<Stream<B>> sequenceSet(
+      final Ord<B> ord,
+      final Stream<Set<B>> stream) {
+    return stream.traverseSet(ord, identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a stream.
+   *
+   * @param stream the given stream
+   * @param <B>    the type of the stream value
+   * @return the stream
+   */
+  public static <B> Stream<Stream<B>> sequenceStream(
+      final Stream<Stream<B>> stream) {
+    return stream.traverseStream(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a trampoline.
+   *
+   * @param stream the given trampoline
+   * @param <B>    the type of the stream value
+   * @return the stream
+   */
+  public static <B> Trampoline<Stream<B>> sequenceTrampoline(
+      final Stream<Trampoline<B>> stream) {
+    return stream.traverseTrampoline(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a validation.
+   *
+   * @param stream the given stream
+   * @param <E>    the type of the failure value
+   * @param <B>    the type of the success value
+   * @return the validation
+   */
+  public static <E, B> Validation<E, Stream<B>> sequenceValidation(
+      final Stream<Validation<E, B>> stream) {
+    return stream.traverseValidation(identity());
+  }
+
+  /**
+   * Sequence the given stream and collect the output as a validation; use the given semigroup to reduce the errors.
+   *
+   * @param semigroup the given semigroup
+   * @param stream    the given stream
+   * @param <E>       the type of the failure value
+   * @param <B>       the type of the success value
+   * @return the validation
+   */
+  public static <E, B> Validation<E, Stream<B>> sequenceValidation(
+      final Semigroup<E> semigroup,
+      final Stream<Validation<E, B>> stream) {
+    return stream.traverseValidation(semigroup, identity());
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <B, L> Either<L, Stream<B>> traverseEither(
+      final F<A, Either<L, B>> f) {
+    return traverseEitherRight(f);
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output on the left side of an either.
+   *
+   * @param f   the given function
+   * @param <R> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <R, B> Either<Stream<B>, R> traverseEitherLeft(
+      final F<A, Either<B, R>> f) {
+    return foldRight1(
+        (
+            element,
+            either) -> f.f(element).left().bind(elementInner -> either.left().map(stream -> stream.cons(elementInner))),
+        Either.left(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output on the right side of an either.
+   *
+   * @param f   the given function
+   * @param <L> the type of the left value
+   * @param <B> the type of the right value
+   * @return the either
+   */
+  public <L, B> Either<L, Stream<B>> traverseEitherRight(
+      final F<A, Either<L, B>> f) {
+    return foldRight1(
+        (
+            element,
+            either) -> f.f(element).right().bind(elementInner -> either.right().map(stream -> stream.cons(elementInner))),
+        Either.right(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a function.
+   *
+   * @param f   the given function
+   * @param <C> the type of the input value
+   * @param <B> the type of the output value
+   * @return the function
+   */
+  public <C, B> F<C, Stream<B>> traverseF(
+      final F<A, F<C, B>> f) {
+    return foldRight1(
+        (
+            element,
+            fInner) -> Function.bind(f.f(element), elementInner -> andThen(fInner, stream -> stream.cons(elementInner))),
+        Function.constant(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as an IO.
+   *
+   * @param f   the given function
+   * @param <B> the type of the IO value
+   * @return the IO
+   */
+  public <B> IO<Stream<B>> traverseIO(
+      final F<A, IO<B>> f) {
+    return foldRight1(
+        (
+            element,
+            io) -> IOFunctions.bind(f.f(element), elementInner -> IOFunctions.map(io, stream -> stream.cons(elementInner))),
+        IOFunctions.unit(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a list.
+   *
+   * @param f   the given function
+   * @param <B> the type of the list value
+   * @return the list
+   */
+  public <B> List<Stream<B>> traverseList(
+      final F<A, List<B>> f) {
+    return foldRight1(
+        (
+            element,
+            list) -> f.f(element).bind(elementInner -> list.map(stream -> stream.cons(elementInner))),
+        List.single(nil()));
+  }
+
+  /**
+   * Traverses through the Seq with the given function
+   *
+   * @param f The function that produces Option value
+   * @return none if applying f returns none to any element of the seq or f mapped seq in some .
+   */
+  public <B> Option<Stream<B>> traverseOption(
+      final F<A, Option<B>> f) {
+    return foldRight1(
+        (
+            element,
+            option) -> f.f(element).bind(elementInner -> option.map(stream -> stream.cons(elementInner))),
+        Option.some(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a p1.
+   *
+   * @param f   the given function
+   * @param <B> the type of the p1 value
+   * @return the p1
+   */
+  public <B> P1<Stream<B>> traverseP1(
+      final F<A, P1<B>> f) {
+    return foldRight1(
+        (
+            element,
+            p1) -> f.f(element).bind(elementInner -> p1.map(stream -> stream.cons(elementInner))),
+        P.p(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a seq.
+   *
+   * @param f   the given function
+   * @param <B> the type of the seq value
+   * @return the seq
+   */
+  public <B> Seq<Stream<B>> traverseSeq(
+      final F<A, Seq<B>> f) {
+    return foldRight1(
+        (
+            element,
+            seq) -> f.f(element).bind(elementInner -> seq.map(stream -> stream.cons(elementInner))),
+        Seq.single(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a set; use the given ord to order the set.
+   *
+   * @param ord the given ord
+   * @param f   the given function
+   * @param <B> the type of the set value
+   * @return the set
+   */
+  public <B> Set<Stream<B>> traverseSet(
+      final Ord<B> ord,
+      final F<A, Set<B>> f) {
+    final Ord<Stream<B>> seqOrd = Ord.streamOrd(ord);
+    return foldRight1(
+        (
+            element,
+            set) -> f.f(element).bind(seqOrd, elementInner -> set.map(seqOrd, seq -> seq.cons(elementInner))),
+        Set.single(seqOrd, nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a stream.
+   *
+   * @param f   the given function
+   * @param <B> the type of the stream value
+   * @return the stream
+   */
+  public <B> Stream<Stream<B>> traverseStream(
+      final F<A, Stream<B>> f) {
+    return foldRight1(
+        (
+            element,
+            stream) -> f.f(element).bind(elementInner -> stream.map(seq -> seq.cons(elementInner))),
+        Stream.single(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a trampoline.
+   *
+   * @param f   the given function
+   * @param <B> the type of the trampoline value
+   * @return the trampoline
+   */
+  public <B> Trampoline<Stream<B>> traverseTrampoline(
+      final F<A, Trampoline<B>> f) {
+    return foldRight1(
+        (
+            element,
+            trampoline) -> f.f(element).bind(elementInner -> trampoline.map(seq -> seq.cons(elementInner))),
+        Trampoline.pure(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a validation.
+   *
+   * @param f   the given function
+   * @param <E> the type of the failure value
+   * @param <B> the type of the success value
+   * @return the validation
+   */
+  public final <E, B> Validation<E, Stream<B>> traverseValidation(
+      final F<A, Validation<E, B>> f) {
+    return foldRight1(
+        (
+            element,
+            validation) -> f.f(element).bind(elementInner -> validation.map(stream -> stream.cons(elementInner))),
+        Validation.success(nil()));
+  }
+
+  /**
+   * Traverse this stream with the given function and collect the output as a validation; use the given semigroup to
+   * reduce the errors.
+   *
+   * @param semigroup the given semigroup
+   * @param f         the given function
+   * @param <E>       the type of the failure value
+   * @param <B>       the type of the success value
+   * @return the validation
+   */
+  public final <E, B> Validation<E, Stream<B>> traverseValidation(
+      final Semigroup<E> semigroup,
+      final F<A, Validation<E, B>> f) {
+    return foldRight1(
+        (
+            element,
+            validation) -> f.f(element).map(Stream::single).accumulate(semigroup, validation, (stream1, stream2) -> stream1.append(stream2)),
+        Validation.success(nil()));
+  }
 }
diff --git a/core/src/test/java/fj/data/IOFunctionsTest.java b/core/src/test/java/fj/data/IOFunctionsTest.java
index b943db36..5213878c 100644
--- a/core/src/test/java/fj/data/IOFunctionsTest.java
+++ b/core/src/test/java/fj/data/IOFunctionsTest.java
@@ -73,7 +73,7 @@ public void testTraverseIO() throws IOException {
     System.setOut(new PrintStream(outContent));
     stream.traverseIO(IOFunctions::stdoutPrint).run();
     System.setOut(originalOut);
-    assertThat(outContent.toString(), is("foobar3bar2foo1"));
+    assertThat(outContent.toString(), is("foo1bar2foobar3"));
   }
 
   @Test
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index 999a3a3e..313678aa 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -2,13 +2,40 @@
 
 import fj.Equal;
 import fj.P2;
+import fj.control.Trampoline;
 import org.junit.Test;
 
+import java.io.IOException;
 import java.util.ConcurrentModificationException;
 
+import static fj.Function.constant;
+import static fj.Ord.*;
+import static fj.P.p;
+import static fj.Semigroup.listSemigroup;
+import static fj.data.Either.left;
+import static fj.data.Either.right;
+import static fj.data.List.arrayList;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+import static fj.data.Seq.arraySeq;
+import static fj.data.Seq.empty;
+import static fj.data.Stream.sequenceEitherLeft;
+import static fj.data.Stream.sequenceEitherRight;
+import static fj.data.Stream.sequenceF;
+import static fj.data.Stream.sequenceIO;
+import static fj.data.Stream.sequenceList;
+import static fj.data.Stream.sequenceOption;
+import static fj.data.Stream.sequenceP1;
+import static fj.data.Stream.sequenceSeq;
+import static fj.data.Stream.sequenceSet;
+import static fj.data.Stream.sequenceStream;
+import static fj.data.Stream.sequenceTrampoline;
+import static fj.data.Stream.sequenceValidation;
 import static fj.data.Stream.*;
+import static fj.data.Validation.*;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
 /**
@@ -103,4 +130,214 @@ public void testMinus() {
         assertThat(s1.minus(Equal.charEqual, s2),
                 is(stream(new Character[]{'a', 'c', 'd'})));
     }
+
+  @Test
+  public void testSequenceEither() {
+    assertEquals(right(nil()), sequenceEither(nil()));
+    assertEquals(right(single("zero")), sequenceEither(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEither(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherLeft() {
+    assertEquals(left(nil()), sequenceEitherLeft(nil()));
+    assertEquals(left(single("zero")), sequenceEitherLeft(single(left("zero"))));
+    assertEquals(right("zero"), sequenceEitherLeft(single(right("zero"))));
+  }
+
+  @Test
+  public void testSequenceEitherRight() {
+    assertEquals(right(nil()), sequenceEitherRight(nil()));
+    assertEquals(right(single("zero")), sequenceEitherRight(single(right("zero"))));
+    assertEquals(left("zero"), sequenceEitherRight(single(left("zero"))));
+  }
+
+  @Test
+  public void testSequenceF() {
+    assertEquals(constant(nil()).f(1), sequenceF(nil()).f(1));
+    assertEquals(constant(single("zero")).f(1), sequenceF(single(constant("zero"))).f(1));
+  }
+
+  @Test
+  public void testSequenceIO()
+          throws IOException {
+    assertEquals(IOFunctions.lazy(constant(nil())).run(), sequenceIO(nil()).run());
+    assertEquals(IOFunctions.lazy(constant(single("zero"))).run(), sequenceIO(single(IOFunctions.lazy(constant("zero")))).run());
+  }
+
+  @Test
+  public void testSequenceList() {
+    assertEquals(List.single(nil()), sequenceList(nil()));
+    assertEquals(List.nil(), sequenceList(single(List.nil())));
+    assertEquals(List.single(single("zero")), sequenceList(single(List.single("zero"))));
+    assertEquals(arrayList(single("zero"), single("one")), sequenceList(single(arrayList("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceOption() {
+    assertEquals(some(nil()), sequenceOption(nil()));
+    assertEquals(none(), sequenceOption(single(none())));
+    assertEquals(some(single("zero")), sequenceOption(single(some("zero"))));
+  }
+
+  @Test
+  public void testSequenceP1() {
+    assertEquals(p(nil()), sequenceP1(nil()));
+    assertEquals(p(single("zero")), sequenceP1(single(p("zero"))));
+  }
+
+  @Test
+  public void testSequenceSeq() {
+    assertEquals(Seq.single(nil()), sequenceSeq(nil()));
+    assertEquals(Seq.empty(), sequenceSeq(single(Seq.empty())));
+    assertEquals(Seq.single(single("zero")), sequenceSeq(single(Seq.single("zero"))));
+    assertEquals(arraySeq(single("zero"), single("one")), sequenceSeq(single(arraySeq("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceSet() {
+    assertEquals(Set.arraySet(streamOrd(stringOrd), nil()), sequenceSet(stringOrd, nil()));
+    assertEquals(Set.empty(streamOrd(stringOrd)), sequenceSet(stringOrd, single(Set.empty(stringOrd))));
+    assertEquals(Set.arraySet(streamOrd(stringOrd), single("zero")), sequenceSet(stringOrd, single(Set.single(stringOrd, "zero"))));
+    assertEquals(Set.arraySet(streamOrd(stringOrd), single("zero"), single("one")), sequenceSet(stringOrd, single(Set.arraySet(stringOrd, "zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceStream() {
+    assertEquals(single(nil()), sequenceStream(nil()));
+    assertEquals(nil(), sequenceStream(single(nil())));
+    assertEquals(single(single("zero")), sequenceStream(single(single("zero"))));
+    assertEquals(arrayStream(single("zero"), single("one")), sequenceStream(single(arrayStream("zero", "one"))));
+  }
+
+  @Test
+  public void testSequenceTrampoline() {
+    assertEquals(Trampoline.pure(nil()).run(), sequenceTrampoline(nil()).run());
+    assertEquals(Trampoline.pure(single(0)).run(), sequenceTrampoline(single(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testSequenceValidation() {
+    assertEquals(success(nil()), sequenceValidation(nil()));
+    assertEquals(fail(single(0)), sequenceValidation(single(fail(single(0)))));
+    assertEquals(success(single(0)), sequenceValidation(single(success(0))));
+  }
+
+  @Test
+  public void testSequenceValidationSemigroup() {
+    assertEquals(success(nil()), sequenceValidation(listSemigroup(), nil()));
+    assertEquals(fail(List.single(0)), sequenceValidation(listSemigroup(), single(fail(List.single(0)))));
+    assertEquals(success(single(0)), sequenceValidation(listSemigroup(), single(success(0))));
+  }
+
+  @Test
+  public void testTraverseEitherLeft() {
+    assertEquals(left(nil()), nil().traverseEitherLeft(constant(left(0))));
+    assertEquals(left(single(0)), single("zero").traverseEitherLeft(constant(left(0))));
+    assertEquals(left(nil()), nil().traverseEitherLeft(constant(right(0))));
+    assertEquals(right(0), single("zero").traverseEitherLeft(constant(right(0))));
+  }
+
+  @Test
+  public void testTraverseEitherRight() {
+    assertEquals(right(nil()), nil().traverseEitherRight(constant(right(0))));
+    assertEquals(right(single(0)), single("zero").traverseEitherRight(constant(right(0))));
+    assertEquals(right(nil()), nil().traverseEitherRight(constant(left(0))));
+    assertEquals(left(0), single("zero").traverseEitherRight(constant(left(0))));
+  }
+
+  @Test
+  public void testTraverseF() {
+    assertEquals(constant(nil()).f(1), nil().traverseF(constant(constant(0))).f(1));
+    assertEquals(constant(single(0)).f(1), single("zero").traverseF(constant(constant(0))).f(1));
+  }
+
+  @Test
+  public void testTraverseIO()
+          throws IOException {
+    assertEquals(IOFunctions.lazy(constant(nil())).run(), nil().traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+    assertEquals(IOFunctions.lazy(constant(single(0))).run(), single("zero").traverseIO(constant(IOFunctions.lazy(constant(0)))).run());
+  }
+
+  @Test
+  public void testTraverseList() {
+    assertEquals(List.single(nil()), nil().traverseList(constant(List.nil())));
+    assertEquals(List.nil(), single("zero").traverseList(constant(List.nil())));
+    assertEquals(List.single(nil()), nil().traverseList(constant(List.single(0))));
+    assertEquals(List.single(single(0)), single("zero").traverseList(constant(List.single(0))));
+    assertEquals(List.single(nil()), nil().traverseList(constant(arrayList(0, 1))));
+    assertEquals(arrayList(single(0), single(1)), single("zero").traverseList(constant(arrayList(0, 1))));
+  }
+
+  @Test
+  public void testTraverseOption() {
+    assertEquals(some(nil()), nil().traverseOption(constant(none())));
+    assertEquals(none(), single("zero").traverseOption(constant(none())));
+    assertEquals(some(nil()), nil().traverseOption(constant(some(0))));
+    assertEquals(some(single(0)), single("zero").traverseOption(constant(some(0))));
+  }
+
+  @Test
+  public void testTraverseP1() {
+    assertEquals(p(nil()), nil().traverseP1(constant(p(0))));
+    assertEquals(p(single(0)), single("zero").traverseP1(constant(p(0))));
+  }
+
+  @Test
+  public void testTraverseSeq() {
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(empty())));
+    assertEquals(Seq.empty(), single("zero").traverseSeq(constant(empty())));
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(single(0)), single("zero").traverseSeq(constant(Seq.single(0))));
+    assertEquals(Seq.single(nil()), nil().traverseSeq(constant(arraySeq(0, 1))));
+    assertEquals(arraySeq(single(0), single(1)), single("zero").traverseSeq(constant(arraySeq(0, 1))));
+  }
+
+  @Test
+  public void testTraverseSet() {
+    assertEquals(Set.arraySet(streamOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.empty(streamOrd(intOrd)), single("zero").traverseSet(intOrd, constant(Set.empty(intOrd))));
+    assertEquals(Set.single(streamOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(streamOrd(intOrd), single(0)), single("zero").traverseSet(intOrd, constant(Set.single(intOrd, 0))));
+    assertEquals(Set.single(streamOrd(intOrd), nil()), nil().traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+    assertEquals(Set.arraySet(streamOrd(intOrd), single(0), single(1)), single("zero").traverseSet(intOrd, constant(Set.arraySet(intOrd, 0, 1))));
+  }
+
+  @Test
+  public void testTraverseStream() {
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.nil(), single("zero").traverseStream(constant(Stream.nil())));
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(single(0)), single("zero").traverseStream(constant(Stream.single(0))));
+    assertEquals(Stream.single(nil()), nil().traverseStream(constant(Stream.arrayStream(0, 1))));
+    assertEquals(Stream.arrayStream(single(0), single(1)), single("zero").traverseStream(constant(Stream.arrayStream(0, 1))));
+  }
+
+  @Test
+  public void testTraverseTrampoline() {
+    assertEquals(Trampoline.pure(nil()).run(), nil().traverseTrampoline(constant(Trampoline.pure(0))).run());
+    assertEquals(Trampoline.pure(single(0)).run(), single("zero").traverseTrampoline(constant(Trampoline.pure(0))).run());
+  }
+
+  @Test
+  public void testTraverseValidation() {
+    assertEquals(success(nil()), nil().traverseValidation(constant(fail(single(0)))));
+    assertEquals(fail(single(0)), single("zero").traverseValidation(constant(fail(single(0)))));
+    assertEquals(success(nil()), nil().traverseValidation(constant(success(0))));
+    assertEquals(success(single(0)), single("zero").traverseValidation(constant(success(0))));
+
+    assertEquals(success(arraySeq(0, 2, 4, 6, 8)), arraySeq(0, 2, 4, 6, 8).traverseValidation(i -> condition(i % 2 == 0, List.single(i), i)));
+    assertEquals(fail(List.single(1)), arraySeq(0, 1, 2, 3, 4, 5, 6, 7, 8, 9).traverseValidation(i -> condition(i % 2 == 0, List.single(i), i)));
+  }
+
+  @Test
+  public void testTraverseValidationSemigroup() {
+    assertEquals(success(nil()), nil().traverseValidation(listSemigroup(), constant(fail(List.single(0)))));
+    assertEquals(fail(List.single(0)), single("zero").traverseValidation(listSemigroup(), constant(fail(List.single(0)))));
+    assertEquals(success(nil()), nil().traverseValidation(listSemigroup(), constant(success(0))));
+    assertEquals(success(single(0)), single("zero").traverseValidation(listSemigroup(), constant(success(0))));
+
+    assertEquals(success(arraySeq(0, 2, 4, 6, 8)), arraySeq(0, 2, 4, 6, 8).traverseValidation(listSemigroup(), i -> condition(i % 2 == 0, List.single(i), i)));
+    assertEquals(fail(arrayList(1, 3, 5, 7, 9)), arraySeq(0, 1, 2, 3, 4, 5, 6, 7, 8, 9).traverseValidation(listSemigroup(), i -> condition(i % 2 == 0, List.single(i), i)));
+  }
 }

From 254e3f55d964ef27278dbfb51ef0981f7e07c96f Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Feb 2021 14:24:27 +1000
Subject: [PATCH 279/336] Fixed code to not use Java 8 features

---
 .../fj/control/parallel/StrategyTest.java     |  9 +++++-
 core/src/test/java/fj/data/OptionTest.java    | 30 ++++++++---------
 .../src/test/java/fj/data/ValidationTest.java | 32 +++++++++----------
 3 files changed, 39 insertions(+), 32 deletions(-)

diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
index 8475b35a..0c605829 100644
--- a/core/src/test/java/fj/control/parallel/StrategyTest.java
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -5,6 +5,7 @@
 import fj.P1;
 import fj.Unit;
 import fj.data.Enumerator;
+import fj.data.Java;
 import fj.data.List;
 import fj.data.Stream;
 import org.junit.Test;
@@ -49,10 +50,16 @@ public void testStrategyCompletion() {
     @Test
     public void testStrategyMergeAll() {
         final List<Integer> l = List.range(0, 100);
-        final List<P1<Integer>> p1s = mergeAll(l.map(x -> CompletableFuture.supplyAsync(() -> x)));
+        final List<P1<Integer>> p1s = mergeAll(l.map(x -> future(x)));
         assertThat(P1.sequence(p1s)._1(), is(l));
     }
 
+    public static <A> Future<A> future(A a) {
+        FutureTask<A> ft = new FutureTask<>(() -> a);
+        new Thread(ft).start();
+        return ft;
+    }
+
     @Test
     public void testStrategyCallables() throws Exception {
         final Strategy<Callable<Integer>> s = strategy(c -> c);
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index da5ef065..5a7bbdbf 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -75,7 +75,7 @@ public void testBind1() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), 0), list.index(0).bind(Option::some));
         });
 
@@ -87,7 +87,7 @@ public void testBind2() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1)), list.index(0).bind(list.index(1), p2()));
         });
   }
@@ -98,7 +98,7 @@ public void testBind3() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2)), list.index(0).bind(list.index(1), list.index(2), p3()));
         });
 
@@ -110,7 +110,7 @@ public void testBind4() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3)), list.index(0).bind(list.index(1), list.index(2), list.index(3), p4()));
         });
 
@@ -122,7 +122,7 @@ public void testBind5() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), p5()));
         });
   }
@@ -133,7 +133,7 @@ public void testBind6() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), p6()));
         });
   }
@@ -144,7 +144,7 @@ public void testBind7() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), p7()));
         });
   }
@@ -155,7 +155,7 @@ public void testBind8() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).bind(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8()));
         });
   }
@@ -166,7 +166,7 @@ public void testBindProduct2() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1)), list.index(0).bindProduct(list.index(1)));
         });
   }
@@ -177,7 +177,7 @@ public void testBindProduct3() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2)), list.index(0).bindProduct(list.index(1), list.index(2)));
         });
 
@@ -189,7 +189,7 @@ public void testBindProduct4() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3)));
         });
 
@@ -201,7 +201,7 @@ public void testBindProduct5() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4)));
         });
   }
@@ -212,7 +212,7 @@ public void testBindProduct6() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5)));
         });
   }
@@ -223,7 +223,7 @@ public void testBindProduct7() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6)));
         });
   }
@@ -234,7 +234,7 @@ public void testBindProduct8() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Option<Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.forall(Option::isSome), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).bindProduct(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7)));
         });
   }
diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
index 0df2deb9..bf2c34e9 100644
--- a/core/src/test/java/fj/data/ValidationTest.java
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -35,7 +35,7 @@ public void testAccumulateSemigroup2() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1), p2()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(Semigroup.listSemigroup(), list.index(1), uncurryF2(p2())));
@@ -49,7 +49,7 @@ public void testAccumulateSemigroup3() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), p3()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), uncurryF3(p3())));
@@ -64,7 +64,7 @@ public void testAccumulateSemigroup4() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), p4()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), uncurryF4(p4())));
@@ -79,7 +79,7 @@ public void testAccumulateSemigroup5() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), p5()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), uncurryF5(p5())));
@@ -93,7 +93,7 @@ public void testAccumulateSemigroup6() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), p6()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), uncurryF6(p6())));
@@ -107,7 +107,7 @@ public void testAccumulateSemigroup7() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), p7()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), uncurryF7(p7())));
@@ -121,7 +121,7 @@ public void testAccumulateSemigroup8() {
             accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(iif(list.exists(Validation::isFail), list.filter(Validation::isFail).bind(validation -> validation.fail())), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7)));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8()));
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).bind(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(Semigroup.listSemigroup(),list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), uncurryF8(P.<Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer>p8())));
@@ -134,7 +134,7 @@ public void testAccumulate0() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), 0), list.index(0).accumulate());
         });
   }
@@ -145,7 +145,7 @@ public void testAccumulate1() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), 0), list.index(0).accumulate(identity()));
         });
 
@@ -157,7 +157,7 @@ public void testAccumulate2() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1)), list.index(0).accumulate(list.index(1), P::p));
         });
   }
@@ -168,7 +168,7 @@ public void testAccumulate3() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2)), list.index(0).accumulate(list.index(1), list.index(2), P::p));
         });
 
@@ -180,7 +180,7 @@ public void testAccumulate4() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), P::p));
         });
 
@@ -192,7 +192,7 @@ public void testAccumulate5() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), P::p));
         });
   }
@@ -203,7 +203,7 @@ public void testAccumulate6() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), P::p));
         });
   }
@@ -214,7 +214,7 @@ public void testAccumulate7() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), P::p));
         });
   }
@@ -225,7 +225,7 @@ public void testAccumulate8() {
         .foldLeft(accumulator -> list -> accumulator.isEmpty() ?
             list.map(List::single) :
             accumulator.bind(accumulatorElement -> list.map(accumulatorElement::snoc)), List.<List<Validation<List<String>, Integer>>>nil())
-        .forEach(list -> {
+        .foreachDoEffect(list -> {
           assertEquals(condition(list.forall(Validation::isSuccess), list.filter(Validation::isFail).map(validation -> validation.fail()), p(0, 1, 2, 3, 4, 5, 6, 7)), list.index(0).accumulate(list.index(1), list.index(2), list.index(3), list.index(4), list.index(5), list.index(6), list.index(7), P::p));
         });
   }

From 8bf7192dec8054aa77b4db157e1237fc4670f7dd Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Mar 2021 01:12:16 +1000
Subject: [PATCH 280/336] Update release notes for 4.8, 4.8.1 and release notes

---
 etc/release-notes/release-notes-4.8.1.adoc | 34 ++++++++++++++++++
 etc/release-notes/release-notes-4.8.adoc   | 41 +++++++++++++++++-----
 etc/release-process.txt                    | 35 ++++++++++++++++++
 3 files changed, 102 insertions(+), 8 deletions(-)
 create mode 100644 etc/release-notes/release-notes-4.8.1.adoc

diff --git a/etc/release-notes/release-notes-4.8.1.adoc b/etc/release-notes/release-notes-4.8.1.adoc
new file mode 100644
index 00000000..45deb658
--- /dev/null
+++ b/etc/release-notes/release-notes-4.8.1.adoc
@@ -0,0 +1,34 @@
+
+= Release 4.8.1
+
+Released: 8 Oct 2018
+
+== Enhancements
+
+- Add Trampoline.suspend(final F0<Trampoline<A>> a).  See #367 https://github.com/functionaljava/functionaljava/pull/367.
+
+== Fixes
+
+- Fix regression in lifted semigroup sum. Fix #365, see #366 https://github.com/functionaljava/functionaljava/pull/366.
+
+== Internal
+
+- Fix compile under jdk11. Enable jdk11 travis build, see #361 https://github.com/functionaljava/functionaljava/pull/361.
+- Fix warnings, see  #369 https://github.com/functionaljava/functionaljava/pull/369.
+- Add P tests, see #360 https://github.com/functionaljava/functionaljava/pull/360.
+- Exclude consume/ from coverage, see #357 https://github.com/functionaljava/functionaljava/pull/357.
+- Add DList tests, see #356 https://github.com/functionaljava/functionaljava/pull/356
+- Add Visitor tests, see #354 https://github.com/functionaljava/functionaljava/pull/354.
+
+== Breaking Changes
+
+* None.
+
+== Documentation
+
+* None.
+
+== Contributors
+
+* Jean Baptiste Giraudeau
+* Gabor Liptak
diff --git a/etc/release-notes/release-notes-4.8.adoc b/etc/release-notes/release-notes-4.8.adoc
index 22dbc552..7e8aed61 100644
--- a/etc/release-notes/release-notes-4.8.adoc
+++ b/etc/release-notes/release-notes-4.8.adoc
@@ -1,28 +1,53 @@
 
-= Release <version>
+= Release 4.8
 
-Proposed release: <quarter> <year>
+Released: 18 Aug 2018
 
 == Enhancements
 
-* TODO.
+- Enable upload of snapshot artifacts, see https://github.com/functionaljava/functionaljava/commit/e834e8b.
+- Add append methods to all Px classes. Fix #326, see https://github.com/functionaljava/functionaljava/commit/065ed43.
+- Introduce the Eval monad, see https://github.com/functionaljava/functionaljava/commit/98294fc.
+- Fluent Equal/Ord construction, see #333 https://github.com/functionaljava/functionaljava/pull/333
+- Implement Zipper Eq and Hash and add tests, see #343 https://github.com/functionaljava/functionaljava/pull/343.
+- Implement Vector equals, see #350 https://github.com/functionaljava/functionaljava/pull/350.
 
 == Fixes
 
-* TODO.
+- Fixed a bug in the NonEmptyList Semigroup implementation that resulted in the same NonEmptyList appended to itself. Regression in 4.7, see https://github.com/functionaljava/functionaljava/commit/07f94fa.
+- Fixes #334: exception in Either.LeftProjection.traverseIO, see #335 https://github.com/functionaljava/functionaljava/pull/335
 
 == Internal
 
-* TODO.
+- Added Scalacheck Arbitrary implementations for Natural and NonEmptyList, see https://github.com/functionaljava/functionaljava/commit/405c3ec
+- Added unit test coverage for Semigroup implementations.  The StringBuffer and StringBuilder tests fail because both of those types are mutable.  The IO test fails because the ArbitraryIO implementation does not implement equals. See https://github.com/functionaljava/functionaljava/commit/ef81130.
+- Fixed the ArbitraryIO implementation and created a Properties object for testing the IO semigroup.  See https://github.com/functionaljava/functionaljava/commit/a8e979f.
+- Equal: remove reference to static field of LazyString. Fix #321, see https://github.com/functionaljava/functionaljava/commit/6c6dabd.
+- Add IOFunctions tests, see #340 https://github.com/functionaljava/functionaljava/pull/340.
+- Add Stream tests, see #341 https://github.com/functionaljava/functionaljava/pull/341.
+- Add tests for Try, F, FW, Digit.  See #346 https://github.com/functionaljava/functionaljava/pull/346
+- Add Vector tests, see #347 https://github.com/functionaljava/functionaljava/pull/347
+- Add Optic tests, see #348 https://github.com/functionaljava/functionaljava/pull/348
+- Add Parser tests, see #349 https://github.com/functionaljava/functionaljava/pull/349
+- Add FingerTree tests, see #351 https://github.com/functionaljava/functionaljava/pull/351
+- Add TreeZipper tests, see #352 https://github.com/functionaljava/functionaljava/pull/352
+- Add Reader/Writer tests, see #353 https://github.com/functionaljava/functionaljava/pull/353
 
 == Breaking Changes
 
-* TODO.
+None.
 
 == Documentation
 
-* TODO.
+None.
 
 == Contributors
 
-* TODO.
+* Jean Baptiste Giraudeau
+* Ryan Johnson
+* l1cache (cache@bk.ru)
+* Gabor Liptak
+* janbols
+* Iaroslav Zeigerman
+* Signey Quitorio
+
diff --git a/etc/release-process.txt b/etc/release-process.txt
index e9bdbb15..2a87eef2 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -41,3 +41,38 @@ Update the website and Github README.adoc.  This includes adding any features to
 
 Send a message to the group and social media about the release, TODO.
 
+Setup Artifact Signing
+======================
+The below text is a summary from https://gist.github.com/phit/bd3c6d156a2fa5f3b1bc15fa94b3256c.
+
+As of 2021-02-12, for Windows download Gpg4win 3.1.15 at https://gpg4win.org/index.html.  You need to provide 3 things:
+- the public key id
+- the path to the secret key ring file for your private key
+- the passphrase for your private key
+
+Open a command prompt and run "gpg --gen-key" and follow the prompts.
+Get your key id by running: "gpg --list-key"
+
+Example output:
+
+gpg: checking the trustdb
+gpg: marginals needed: 3  completes needed: 1  trust model: pgp
+gpg: depth: 0  valid:   1  signed:   0  trust: 0-, 0q, 0n, 0m, 0f, 1u
+gpg: next trustdb check due at 2019-06-17
+C:/Users/phit/AppData/Roaming/gnupg/pubring.kbx
+-----------------------------------------------
+pub   rsa2048 2017-06-17 [SC] [expires: 2019-06-17]
+      77273D57FA5140E5A91905087A1B92B81840D019
+uid           [ultimate] phit@hush.com
+sub   rsa2048 2017-06-17 [E] [expires: 2019-06-17]
+
+In this case we only have one key, 77273D57FA5140E5A91905087A1B92B81840D019 or short* 1840D019 which is basically just the last 8 characters of the long ID.
+
+Export the key using "gpg --export-secret-key <key> > %UserProfile%\secring.gpg"
+
+In %UserProfile%\.gradle\gradle.properties, set the values below:
+
+signing.keyId=XXXXXXXX
+signing.password=mypassword
+signing.secretKeyRingFile=path/to/secring.gpg
+

From e9aa23acf3d2b53b9b114dd2e75f163028e52c42 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Mar 2021 01:15:54 +1000
Subject: [PATCH 281/336] Removed obsolete change log file and directed from
 the readme to the release notes dir

---
 ChangeLog.md | 52 ----------------------------------------------------
 README.adoc  |  4 ++++
 2 files changed, 4 insertions(+), 52 deletions(-)
 delete mode 100644 ChangeLog.md

diff --git a/ChangeLog.md b/ChangeLog.md
deleted file mode 100644
index acdbedea..00000000
--- a/ChangeLog.md
+++ /dev/null
@@ -1,52 +0,0 @@
-4.8.1
------
-
-### Enhancements
-
-- Add Trampoline.suspend(final F0<Trampoline<A>> a). (see [#367](https://github.com/functionaljava/functionaljava/pull/367));
-
-### Fixes
-
-- Fix regression in lifted semigroup sum. Fix #365 (see [#366](https://github.com/functionaljava/functionaljava/pull/366));
-
-### Internal
-
-- Fix compile under jdk11. Enable jdk11 travis build. (see [#361](https://github.com/functionaljava/functionaljava/pull/361));
-- Fix warnings (see [#369](https://github.com/functionaljava/functionaljava/pull/369));
-- Add P tests (see [#360](https://github.com/functionaljava/functionaljava/pull/360));
-- Exclude consume/ from coverage (see [#357](https://github.com/functionaljava/functionaljava/pull/357));
-- Add DList tests (see [#356](https://github.com/functionaljava/functionaljava/pull/356));
-- Add Visitor tests (see [#354](https://github.com/functionaljava/functionaljava/pull/354));
-
-4.8
----
-
-### Enhancements
-
-- Enable upload of snapshot artifacts. (see [`e834e8b`](https://github.com/functionaljava/functionaljava/commit/e834e8b));
-- Add append methods to all Px classes. Fix #326 (see [`065ed43`](https://github.com/functionaljava/functionaljava/commit/065ed43));
-- Introduce the Eval monad (see [`98294fc`](https://github.com/functionaljava/functionaljava/commit/98294fc));
-- Fluent Equal/Ord construction (see [#333](https://github.com/functionaljava/functionaljava/pull/333));
-- Implement Zipper Eq and Hash and add tests (see [#343](https://github.com/functionaljava/functionaljava/pull/343));
-- Implement Vector equals (see [#350](https://github.com/functionaljava/functionaljava/pull/350));
-
-### Fixes
-
-- Fixed a bug in the NonEmptyList Semigroup implementation that resulted in the same NonEmptyList appended to itself. (Regression in 4.7, see [`07f94fa`](https://github.com/functionaljava/functionaljava/commit/07f94fa));
-- Fixes #334: exception in Either.LeftProjection.traverseIO (see [#335](https://github.com/functionaljava/functionaljava/pull/335));
-
-### Internal
-
-- Added Scalacheck Arbitrary implementations for Natural and NonEmptyList. (see [`405c3ec`](https://github.com/functionaljava/functionaljava/commit/405c3ec));
-- Added unit test coverage for Semigroup implementations.  The StringBuffer and StringBuilder tests fail because both of those types are mutable.  The IO test fails because the ArbitraryIO implementation does not implement equals. (see [`ef81130`](https://github.com/functionaljava/functionaljava/commit/ef81130));
-- Fixed the ArbitraryIO implementation and created a Properties object for testing the IO semigroup. (see [`a8e979f`](https://github.com/functionaljava/functionaljava/commit/a8e979f));
-- Equal: remove reference to static field of LazyString. Fix #321 (see [`6c6dabd`](https://github.com/functionaljava/functionaljava/commit/6c6dabd));
-- Add IOFunctions tests (see [#340](https://github.com/functionaljava/functionaljava/pull/340));
-- Add Stream tests (see [#341](https://github.com/functionaljava/functionaljava/pull/341));
-- Add tests for Try, F, FW, Digit (see [#346](https://github.com/functionaljava/functionaljava/pull/346));
-- Add Vector tests (see [#347](https://github.com/functionaljava/functionaljava/pull/347));
-- Add Optic tests (see [#348](https://github.com/functionaljava/functionaljava/pull/348));
-- Add Parser tests (see [#349](https://github.com/functionaljava/functionaljava/pull/349));
-- Add FingerTree tests (see [#351](https://github.com/functionaljava/functionaljava/pull/351));
-- Add TreeZipper tests (see [#352](https://github.com/functionaljava/functionaljava/pull/352));
-- Add Reader/Writer tests (see [#353](https://github.com/functionaljava/functionaljava/pull/353));
diff --git a/README.adoc b/README.adoc
index 8a3ad347..cb53d003 100644
--- a/README.adoc
+++ b/README.adoc
@@ -122,3 +122,7 @@ A more complete description of the features mentioned above are:
 == License
 
 link:etc/LICENCE[The Functional Java license] uses the BSD 3 license (3-clause license) available at https://en.wikipedia.org/wiki/BSD_licenses[].
+
+== Release Notes
+
+For release notes for each version, see the directory etc/release-notes.
\ No newline at end of file

From 9da757d0777a6bd19b37c52e44ceefec1bcb26d5 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Mar 2021 01:20:56 +1000
Subject: [PATCH 282/336] Prepare for 4.9 release

---
 build.gradle | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index c9d8be40..c264be1c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -47,7 +47,7 @@ allprojects {
 	defaultTasks "build"
 
     ext {
-        isSnapshot = true
+        isSnapshot = false
         fjBaseVersion = "4.9"
 
         snapshotAppendix = "-SNAPSHOT"
@@ -55,7 +55,7 @@ allprojects {
         fjConsumeVersion = "4.8.1"
 
         signModule = false
-        useRetroLambda = false
+        useRetroLambda = true
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"

From c18ab08039573891c54ddd88cc41a77844587272 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Mar 2021 01:43:16 +1000
Subject: [PATCH 283/336] Created 4.9 release notes

---
 etc/release-notes/release-notes-4.9.adoc | 42 ++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 etc/release-notes/release-notes-4.9.adoc

diff --git a/etc/release-notes/release-notes-4.9.adoc b/etc/release-notes/release-notes-4.9.adoc
new file mode 100644
index 00000000..62db8e99
--- /dev/null
+++ b/etc/release-notes/release-notes-4.9.adoc
@@ -0,0 +1,42 @@
+
+= Release 4.9
+
+Released: 14 March 2021
+
+== Enhancements
+
+* Added Gen.streamOf(Gen<A>)
+* Added Option.sequence(Validation<E, Option<A>>)
+* Added Gen.sequence(Validation<E, Gen<A>>)
+* Added Validation sequence and traverse functions to support various types.  Added success and fails functions.
+* Added Option sequence and traverse functions for various types.
+* Added Seq.bind.
+* Added List sequence and traverse functions for various types.
+* Added Ord.seqOrd
+* Added Seq sequence and traverse functions for various types.
+* Added functions to Either.
+* Added State bind synonym for flatMap.
+* Added Steam sequence and traverse functions for various types.
+
+== Fixes
+
+* Fixed Validation.accumulate functions.
+
+== Internal
+
+* Support JPMS modules through 'Automatic-Module-Name'.
+
+== Breaking Changes
+
+* None.
+
+== Documentation
+
+* None.
+
+== Contributors
+
+* Jean Baptiste Giraudeau
+* Gregoire Neuville
+* Drew Taylor
+* Mark Perry

From c7dbd3fda84fec43b3104e0b60dc2a316a98fff4 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 13 Mar 2021 17:30:24 +1000
Subject: [PATCH 284/336] Prep for 4.9 release

---
 etc/release-process.txt | 17 +++++++++++++++++
 gradle.properties       |  2 +-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/etc/release-process.txt b/etc/release-process.txt
index 2a87eef2..b22ec4e4 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -76,3 +76,20 @@ signing.keyId=XXXXXXXX
 signing.password=mypassword
 signing.secretKeyRingFile=path/to/secring.gpg
 
+Upload your key
+
+C:\repos\functionaljava>gpg --list-key
+C:/Users/maper/AppData/Roaming/gnupg/pubring.kbx
+------------------------------------------------
+pub   rsa3072 2021-02-12 [SC] [expires: 2023-02-12]
+      E86A4EC34F25A9CF6118582A7985AAE03F41B2F9
+uid           [ultimate] Mark Perry <maperry78@yahoo.com.au>
+sub   rsa3072 2021-02-12 [E] [expires: 2023-02-12]
+
+
+C:\repos\functionaljava>gpg --keyserver hkp://keyserver.ubuntu.com --send-keys E86A4EC34F25A9CF6118582A7985AAE03F41B2F9
+gpg: sending key 7985AAE03F41B2F9 to hkp://keyserver.ubuntu.com
+
+gradle upload (takes about 3 mins)
+
+
diff --git a/gradle.properties b/gradle.properties
index d4552a30..07c2b60c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = false
+signingEnabled = true

From bcb4d199d2a82eafa7adf1b6b91246db29e45818 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 1 Apr 2021 17:45:39 +1000
Subject: [PATCH 285/336] Upgrade from Gradle 5.6.2 to 6.8.3

---
 build.gradle                             | 26 +++++++++++-------------
 gradle/wrapper/gradle-wrapper.properties |  2 +-
 props-core-scalacheck/build.gradle       |  4 ++++
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/build.gradle b/build.gradle
index d1b829d3..bcd01f5e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,6 +12,7 @@ buildscript {
 
     dependencies {
         classpath "com.github.ben-manes:gradle-versions-plugin:0.27.0"
+        classpath "biz.aQute.bnd:biz.aQute.bnd.gradle:5.3.0"
     }
 
     wrapper {
@@ -20,6 +21,7 @@ buildscript {
     }
 }
 
+
 if (JavaVersion.current().isJava8Compatible()) {
     allprojects {
         tasks.withType(Javadoc) {
@@ -117,8 +119,8 @@ task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
     executionData fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec")
     // We only care about coverage of:
     def projectForFoverage = ["core", "quickcheck", "java-core"]
-    classDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.output)
-    sourceDirectories = files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.allSource.srcDirs)
+    getClassDirectories().from(files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.output))
+    getSourceDirectories().from(files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.allSource.srcDirs))
 
     reports {
         html.enabled = true
@@ -130,8 +132,7 @@ configure(subprojects.findAll { it.name != "props-core" }) {
 
     apply plugin: "maven"
     apply plugin: "signing"
-    apply plugin: "osgi"
-
+    apply plugin: "biz.aQute.bnd.builder"
     sourceCompatibility = "1.8"
 
     javadoc {
@@ -156,16 +157,13 @@ configure(subprojects.findAll { it.name != "props-core" }) {
 
     jar {
         version project.fjVersion
-        manifest {
-            name = 'Functional Java'
-            instruction 'Signature-Version', project.fjVersion
-            instruction 'Bundle-ActivationPolicy', 'lazy'
-            instruction 'Bundle-Vendor', 'functionaljava.org'
-            if(project.name != "core") {
-                instruction 'Require-Bundle', 'org.functionaljava;bundle-version="'+project.fjBaseVersion+'"'
-            }
-            instruction 'Automatic-Module-Name', "functionaljava${project.name == 'core' ? '' : ".$project.name"}"
-        }
+        bnd (
+                'Bundle-Name': 'Functional Java',
+                'Signature-Version': project.fjVersion,
+                'Bundle-ActivationPolicy': 'lazy',
+                'Bundle-Vendor': 'functionaljava.org',
+                'Automatic-Module-Name': "functionaljava${project.name == 'core' ? '' : ".$project.name"}",
+        )
     }
 
     eclipse {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index ca9d6281..8cf6eb5a 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.6.2-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index 5207bf50..f26b5425 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -19,5 +19,9 @@ dependencies {
     testRuntime junitRuntime
 }
 
+tasks.withType(ScalaCompile) {
+    scalaCompileOptions.additionalParameters = ["-feature", "-language:implicitConversions", "-language:postfixOps"]
+}
+
 performSigning(signingEnabled, signModule)
 configureUpload(signingEnabled, signModule)

From 3ddcfe6e15ec840d27719c47c67be493061552d0 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 1 Apr 2021 17:46:08 +1000
Subject: [PATCH 286/336] Target Java 8 JVM

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index bcd01f5e..62f48dde 100644
--- a/build.gradle
+++ b/build.gradle
@@ -106,7 +106,7 @@ subprojects {
 	}
 
     tasks.withType(JavaCompile) {
-        options.compilerArgs.addAll(['--release', '10'])
+        options.compilerArgs.addAll(['--release', '8'])
         if (displayCompilerWarnings) {
 			options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
        }

From 851245c47700063529f55ac416dea09cb55c7bc2 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 1 Apr 2021 17:52:35 +1000
Subject: [PATCH 287/336] Don't sign modules by default

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 07c2b60c..d4552a30 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = true
+signingEnabled = false

From fe4607210b0fdff9d1824b2e166a084bcd3ec32b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 1 Apr 2021 17:52:54 +1000
Subject: [PATCH 288/336] Updated gradle version to 6.8.3

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 62f48dde..57c36c18 100644
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "5.6.2"
+        gradleVersion = "6.8.3"
         distributionType = Wrapper.DistributionType.ALL
     }
 }

From 50aee0c7e35e128b5bdce7b8278ee98d27b16c4a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 2 Apr 2021 00:15:18 +1000
Subject: [PATCH 289/336] Removed F1Functions, F1W, F2Functions and F2W

---
 core/src/main/java/fj/F.java                  |  681 ++++++++-
 core/src/main/java/fj/F1Functions.java        |  687 ---------
 core/src/main/java/fj/F1W.java                |  687 ---------
 core/src/main/java/fj/F2.java                 |  274 +++-
 core/src/main/java/fj/F2Functions.java        |  273 ----
 core/src/main/java/fj/F2W.java                |  254 ---
 core/src/main/java/fj/Monoid.java             |    4 +-
 core/src/main/java/fj/P1.java                 |    2 +-
 core/src/main/java/fj/P2.java                 |    4 +-
 core/src/main/java/fj/P3.java                 |    6 +-
 core/src/main/java/fj/P4.java                 |    8 +-
 core/src/main/java/fj/P5.java                 |   10 +-
 core/src/main/java/fj/P6.java                 |   12 +-
 core/src/main/java/fj/P7.java                 |   14 +-
 core/src/main/java/fj/P8.java                 |   16 +-
 core/src/main/java/fj/Semigroup.java          |    5 +-
 core/src/main/java/fj/control/Trampoline.java |    9 +-
 .../java/fj/control/parallel/ParModule.java   |    4 +-
 core/src/main/java/fj/data/IOFunctions.java   |    5 +-
 core/src/main/java/fj/data/Iteratee.java      |    3 +-
 core/src/main/java/fj/data/List.java          |    2 +-
 core/src/main/java/fj/data/NonEmptyList.java  |    3 +-
 core/src/main/java/fj/data/Reader.java        |    3 +-
 core/src/main/java/fj/data/Tree.java          |    4 +-
 core/src/main/java/fj/data/TreeMap.java       |    7 +-
 core/src/main/java/fj/data/TreeZipper.java    | 1356 ++++++++---------
 core/src/main/java/fj/data/Zipper.java        | 1170 +++++++-------
 .../java/fj/data/fingertrees/FingerTree.java  |  536 +++----
 core/src/test/java/fj/FFunctionsTest.java     |   90 +-
 core/src/test/java/fj/FWFunctionsTest.java    |   23 -
 .../test/java/fj/data/IOFunctionsTest.java    |    3 +-
 .../test/java/fj/function/StringsTest.java    |    3 +-
 .../main/java/fj/demo/Comonad_example.java    |    3 +-
 demo/src/main/java/fj/demo/IODemo.java        |    5 +-
 demo/src/main/java/fj/demo/IOWalkthrough.java |    7 +-
 demo/src/main/java/fj/demo/Primes2.java       |    4 +-
 .../main/java/fj/demo/WriterDemo_Halver.java  |    3 +-
 .../java/fj/demo/concurrent/MapReduce.java    |   15 +-
 .../src/main/java/fj/demo/euler/Problem2.java |    6 +-
 .../src/test/scala/fj/data/CheckHashMap.scala |  236 +--
 .../test/scala/fj/data/CheckIteratee.scala    |    3 +-
 .../src/test/java/fj/data/ReaderTest.java     |    6 +-
 42 files changed, 2730 insertions(+), 3716 deletions(-)
 delete mode 100644 core/src/main/java/fj/F1Functions.java
 delete mode 100644 core/src/main/java/fj/F1W.java
 delete mode 100644 core/src/main/java/fj/F2Functions.java
 delete mode 100644 core/src/main/java/fj/F2W.java
 delete mode 100644 core/src/test/java/fj/FWFunctionsTest.java

diff --git a/core/src/main/java/fj/F.java b/core/src/main/java/fj/F.java
index e2db316e..d2208236 100644
--- a/core/src/main/java/fj/F.java
+++ b/core/src/main/java/fj/F.java
@@ -1,12 +1,27 @@
 package fj;
 
+import fj.control.parallel.Actor;
+import fj.control.parallel.Promise;
+import fj.control.parallel.Strategy;
+import fj.data.*;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.TreeSet;
+import java.util.concurrent.*;
+import java.util.function.Function;
+
+import static fj.data.Option.some;
+import static fj.data.Stream.iterableStream;
+import static fj.data.Zipper.fromStream;
+
 /**
  * A transformation or function from <code>A</code> to <code>B</code>. This type can be represented
  * using the Java 7 closure syntax.
  *
  * @version %build.number%
  */
-public interface F<A, B> {
+public interface F<A, B> extends Function<A, B> {
   /**
    * Transform <code>A</code> to <code>B</code>.
    *
@@ -15,4 +30,668 @@ public interface F<A, B> {
    */
   B f(A a);
 
+  default B apply(A a) {
+    return f(a);
+  }
+
+  /**
+   * Function composition
+   *
+   * @param g A function to compose with this one.
+   * @return The composed function such that this function is applied last.
+   */
+  default <C> F<C, B> o(final F<C, A> g) {
+    return c -> f(g.f(c));
+  }
+
+  /**
+   * First-class function composition
+   *
+   * @return A function that composes this function with another.
+   */
+  default <C> F<F<C, A>, F<C, B>> o() {
+    return g -> o(g);
+  }
+
+  /**
+   * Function composition flipped.
+   *
+   * @param g A function with which to compose this one.
+   * @return The composed function such that this function is applied first.
+   */
+  @SuppressWarnings("unchecked")
+  default <C> F<A, C> andThen(final F<B, C> g) {
+    return g.o(this);
+  }
+
+  /**
+   * First-class composition flipped.
+   *
+   * @return A function that invokes this function and then a given function on the result.
+   */
+  default <C> F<F<B, C>, F<A, C>> andThen() {
+    return g -> andThen(g);
+  }
+
+  /**
+   * Binds a given function across this function (Reader Monad).
+   *
+   * @param g A function that takes the return value of this function as an argument, yielding a new function.
+   * @return A function that invokes this function on its argument and then the given function on the result.
+   */
+  default <C> F<A, C> bind(final F<B, F<A, C>> g) {
+    return a -> g.f(f(a)).f(a);
+  }
+
+  /**
+   * First-class function binding.
+   *
+   * @return A function that binds another function across this function.
+   */
+  default <C> F<F<B, F<A, C>>, F<A, C>> bind() {
+    return g -> bind(g);
+  }
+
+  /**
+   * Function application in an environment (Applicative Functor).
+   *
+   * @param g A function with the same argument type as this function, yielding a function that takes the return
+   *          value of this function.
+   * @return A new function that invokes the given function on its argument, yielding a new function that is then
+   *         applied to the result of applying this function to the argument.
+   */
+  default <C> F<A, C> apply(final F<A, F<B, C>> g) {
+    return a -> g.f(a).f(f(a));
+  }
+
+  /**
+   * First-class function application in an environment.
+   *
+   * @return A function that applies a given function within the environment of this function.
+   */
+  default <C> F<F<A, F<B, C>>, F<A, C>> apply() {
+    return g -> apply(g);
+  }
+
+  /**
+   * Applies this function over the arguments of another function.
+   *
+   * @param g The function over whose arguments to apply this function.
+   * @return A new function that invokes this function on its arguments before invoking the given function.
+   */
+  default <C> F<A, F<A, C>> on(final F<B, F<B, C>> g) {
+    return a1 -> a2 -> g.f(f(a1)).f(f(a2));
+  }
+
+
+
+  /**
+   * Applies this function over the arguments of another function.
+   *
+   * @return A function that applies this function over the arguments of another function.
+   */
+  default <C> F<F<B, F<B, C>>, F<A, F<A, C>>> on() {
+    return g -> on(g);
+  }
+
+  /**
+   * Promotes this function so that it returns its result in a product-1. Kleisli arrow for P1.
+   *
+   * @return This function promoted to return its result in a product-1.
+   */
+  default F<A, P1<B>> lazy() {
+    return a -> P.lazy(() -> f(a));
+  }
+
+  /**
+   * Partial application.
+   *
+   * @param a The <code>A</code> to which to apply this function.
+   * @return The function partially applied to the given argument to return a lazy value.
+   */
+  default P1<B> partial(final A a) {
+    return P.lazy(() -> f(a));
+  }
+
+  /**
+   * Promotes this function to map over a product-1.
+   *
+   * @return This function promoted to map over a product-1.
+   */
+  default F<P1<A>, P1<B>> mapP1() {
+    return p -> p.map(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result in an Option. Kleisli arrow for Option.
+   *
+   * @return This function promoted to return its result in an Option.
+   */
+  default F<A, Option<B>> optionK() {
+    return a -> some(f(a));
+  }
+
+  /**
+   * Promotes this function to map over an optional value.
+   *
+   * @return This function promoted to map over an optional value.
+   */
+  default F<Option<A>, Option<B>> mapOption() {
+    return o -> o.map(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result in a List. Kleisli arrow for List.
+   *
+   * @return This function promoted to return its result in a List.
+   */
+  default F<A, List<B>> listK() {
+    return a -> List.single(f(a));
+  }
+
+  /**
+   * Promotes this function to map over a List.
+   *
+   * @return This function promoted to map over a List.
+   */
+  default F<List<A>, List<B>> mapList() {
+    return x -> x.map(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result in a Stream. Kleisli arrow for Stream.
+   *
+   * @return This function promoted to return its result in a Stream.
+   */
+  default F<A, Stream<B>> streamK() {
+    return a -> Stream.single(f(a));
+  }
+
+  /**
+   * Promotes this function to map over a Stream.
+   *
+   * @return This function promoted to map over a Stream.
+   */
+  default F<Stream<A>, Stream<B>> mapStream() {
+    return x -> x.map(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result in a Array. Kleisli arrow for Array.
+   *
+   * @return This function promoted to return its result in a Array.
+   */
+  default F<A, Array<B>> arrayK() {
+    return a -> Array.single(f(a));
+
+  }
+
+  /**
+   * Promotes this function to map over a Array.
+   *
+   * @return This function promoted to map over a Array.
+   */
+  default F<Array<A>, Array<B>> mapArray() {
+    return x -> x.map(this);
+  }
+
+  /**
+   * Returns a function that contramaps over a given actor.
+   *
+   * @return A function that contramaps over a given actor.
+   */
+  default F<Actor<B>, Actor<A>> contramapActor() {
+    return a -> a.contramap(this);
+  }
+
+  /**
+   * Promotes this function to a concurrent function that returns a Promise of a value.
+   *
+   * @param s A parallel strategy for concurrent execution.
+   * @return A concurrent function that returns a Promise of a value.
+   */
+  default F<A, Promise<B>> promiseK(final Strategy<Unit> s) {
+    return Promise.promise(s, this);
+  }
+
+  /**
+   * Promotes this function to map over a Promise.
+   *
+   * @return This function promoted to map over Promises.
+   */
+  default F<Promise<A>, Promise<B>> mapPromise() {
+    return p -> p.fmap(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result on the left side of an Either.
+   * Kleisli arrow for the Either left projection.
+   *
+   * @return This function promoted to return its result on the left side of an Either.
+   */
+  @SuppressWarnings("unchecked")
+  default <C> F<A, Either<B, C>> eitherLeftK() {
+    return Either.<B, C>left_().o(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result on the right side of an Either.
+   * Kleisli arrow for the Either right projection.
+   *
+   * @return This function promoted to return its result on the right side of an Either.
+   */
+  @SuppressWarnings("unchecked")
+  default <C> F<A, Either<C, B>> eitherRightK() {
+    return Either.<C, B>right_().o(this);
+  }
+
+  /**
+   * Promotes this function to map over the left side of an Either.
+   *
+   * @return This function promoted to map over the left side of an Either.
+   */
+  @SuppressWarnings("unchecked")
+  default <X> F<Either<A, X>, Either<B, X>> mapLeft() {
+    return Either.<A, X, B>leftMap_().f(this);
+  }
+
+  /**
+   * Promotes this function to map over the right side of an Either.
+   *
+   * @return This function promoted to map over the right side of an Either.
+   */
+  @SuppressWarnings("unchecked")
+  default <X> F<Either<X, A>, Either<X, B>> mapRight() {
+    return Either.<X, A, B>rightMap_().f(this);
+  }
+
+  /**
+   * Returns a function that returns the left side of a given Either, or this function applied to the right side.
+   *
+   * @return a function that returns the left side of a given Either, or this function applied to the right side.
+   */
+  default F<Either<B, A>, B> onLeft() {
+    return e -> e.left().on(this);
+  }
+
+  /**
+   * Returns a function that returns the right side of a given Either, or this function applied to the left side.
+   *
+   * @return a function that returns the right side of a given Either, or this function applied to the left side.
+   */
+  default F<Either<A, B>, B> onRight() {
+    return e -> e.right().on(this);
+  }
+
+  /**
+   * Promotes this function to return its value in an Iterable.
+   *
+   * @return This function promoted to return its value in an Iterable.
+   */
+  @SuppressWarnings("unchecked")
+  default F<A, IterableW<B>> iterableK() {
+    return IterableW.<A, B>arrow().f(this);
+  }
+
+  /**
+   * Promotes this function to map over Iterables.
+   *
+   * @return This function promoted to map over Iterables.
+   */
+  @SuppressWarnings("unchecked")
+  default F<Iterable<A>, IterableW<B>> mapIterable() {
+    return IterableW.<A, B>map().f(this).o(IterableW.wrap());
+  }
+
+  /**
+   * Promotes this function to return its value in a NonEmptyList.
+   *
+   * @return This function promoted to return its value in a NonEmptyList.
+   */
+  @SuppressWarnings("unchecked")
+  default F<A, NonEmptyList<B>> nelK() {
+    return NonEmptyList.<B>nel().o(this);
+  }
+
+  /**
+   * Promotes this function to map over a NonEmptyList.
+   *
+   * @return This function promoted to map over a NonEmptyList.
+   */
+  default F<NonEmptyList<A>, NonEmptyList<B>> mapNel() {
+    return list -> list.map(this);
+  }
+
+  /**
+   * Promotes this function to return its value in a Set.
+   *
+   * @param o An order for the set.
+   * @return This function promoted to return its value in a Set.
+   */
+  default F<A, Set<B>> setK(final Ord<B> o) {
+    return a -> Set.single(o, f(a));
+  }
+
+  /**
+   * Promotes this function to map over a Set.
+   *
+   * @param o An order for the resulting set.
+   * @return This function promoted to map over a Set.
+   */
+  default F<Set<A>, Set<B>> mapSet(final Ord<B> o) {
+    return s -> s.map(o, this);
+  }
+
+  /**
+   * Promotes this function to return its value in a Tree.
+   *
+   * @return This function promoted to return its value in a Tree.
+   */
+  default F<A, Tree<B>> treeK() {
+    return a -> Tree.leaf(f(a));
+  }
+
+  /**
+   * Promotes this function to map over a Tree.
+   *
+   * @return This function promoted to map over a Tree.
+   */
+  @SuppressWarnings("unchecked")
+  default F<Tree<A>, Tree<B>> mapTree() {
+    return Tree.<A, B>fmap_().f(this);
+  }
+
+  /**
+   * Returns a function that maps this function over a tree and folds it with the given monoid.
+   *
+   * @param m The monoid with which to fold the mapped tree.
+   * @return a function that maps this function over a tree and folds it with the given monoid.
+   */
+  default F<Tree<A>, B> foldMapTree(final Monoid<B> m) {
+    return Tree.foldMap_(this, m);
+  }
+
+  /**
+   * Promotes this function to return its value in a TreeZipper.
+   *
+   * @return This function promoted to return its value in a TreeZipper.
+   */
+  default F<A, TreeZipper<B>> treeZipperK() {
+    return treeK().andThen(TreeZipper.fromTree());
+  }
+
+  /**
+   * Promotes this function to map over a TreeZipper.
+   *
+   * @return This function promoted to map over a TreeZipper.
+   */
+  default F<TreeZipper<A>, TreeZipper<B>> mapTreeZipper() {
+    return z -> z.map(this);
+  }
+
+  /**
+   * Promotes this function so that it returns its result on the failure side of a Validation.
+   * Kleisli arrow for the Validation failure projection.
+   *
+   * @return This function promoted to return its result on the failure side of a Validation.
+   */
+  default <C> F<A, Validation<B, C>> failK() {
+    return a -> Validation.fail(f(a));
+
+  }
+
+  /**
+   * Promotes this function so that it returns its result on the success side of an Validation.
+   * Kleisli arrow for the Validation success projection.
+   *
+   * @return This function promoted to return its result on the success side of an Validation.
+   */
+  default <C> F<A, Validation<C, B>> successK() {
+    return a -> Validation.success(f(a));
+  }
+
+  /**
+   * Promotes this function to map over the failure side of a Validation.
+   *
+   * @return This function promoted to map over the failure side of a Validation.
+   */
+  default <X> F<Validation<A, X>, Validation<B, X>> mapFail() {
+    return v -> v.f().map(this);
+  }
+
+  /**
+   * Promotes this function to map over the success side of a Validation.
+   *
+   * @return This function promoted to map over the success side of a Validation.
+   */
+  default <X> F<Validation<X, A>, Validation<X, B>> mapSuccess() {
+    return v -> v.map(this);
+  }
+
+  /**
+   * Returns a function that returns the failure side of a given Validation,
+   * or this function applied to the success side.
+   *
+   * @return a function that returns the failure side of a given Validation,
+   *         or this function applied to the success side.
+   */
+  default F<Validation<B, A>, B> onFail() {
+    return v -> v.f().on(this);
+  }
+
+  /**
+   * Returns a function that returns the success side of a given Validation,
+   * or this function applied to the failure side.
+   *
+   * @return a function that returns the success side of a given Validation,
+   *         or this function applied to the failure side.
+   */
+  default F<Validation<A, B>, B> onSuccess() {
+    return v -> v.on(this);
+  }
+
+  /**
+   * Promotes this function to return its value in a Zipper.
+   *
+   * @return This function promoted to return its value in a Zipper.
+   */
+  default F<A, Zipper<B>> zipperK() {
+    return streamK().andThen(s -> fromStream(s).some());
+  }
+
+  /**
+   * Promotes this function to map over a Zipper.
+   *
+   * @return This function promoted to map over a Zipper.
+   */
+  default F<Zipper<A>, Zipper<B>> mapZipper() {
+    return z -> z.map(this);
+  }
+
+  /**
+   * Promotes this function to map over an Equal as a contravariant functor.
+   *
+   * @return This function promoted to map over an Equal as a contravariant functor.
+   */
+  default F<Equal<B>, Equal<A>> contramapEqual() {
+    return e -> e.contramap(this);
+  }
+
+  /**
+   * Promotes this function to map over a Hash as a contravariant functor.
+   *
+   * @return This function promoted to map over a Hash as a contravariant functor.
+   */
+  default F<Hash<B>, Hash<A>> contramapHash() {
+    return h -> h.contramap(this);
+  }
+
+  /**
+   * Promotes this function to map over a Show as a contravariant functor.
+   *
+   * @return This function promoted to map over a Show as a contravariant functor.
+   */
+  default F<Show<B>, Show<A>> contramapShow() {
+    return s -> s.contramap(this);
+  }
+
+  /**
+   * Promotes this function to map over the first element of a pair.
+   *
+   * @return This function promoted to map over the first element of a pair.
+   */
+  default <C> F<P2<A, C>, P2<B, C>> mapFst() {
+    return P2.map1_(this);
+  }
+
+  /**
+   * Promotes this function to map over the second element of a pair.
+   *
+   * @return This function promoted to map over the second element of a pair.
+   */
+  default <C> F<P2<C, A>, P2<C, B>> mapSnd() {
+    return P2.map2_(this);
+  }
+
+  /**
+   * Promotes this function to map over both elements of a pair.
+   *
+   * @return This function promoted to map over both elements of a pair.
+   */
+  default F<P2<A, A>, P2<B, B>> mapBoth() {
+    return p2 -> P2.map(this, p2);
+  }
+
+  /**
+   * Maps this function over a SynchronousQueue.
+   *
+   * @param as A SynchronousQueue to map this function over.
+   * @return A new SynchronousQueue with this function applied to each element.
+   */
+  default SynchronousQueue<B> mapJ(final SynchronousQueue<A> as) {
+    final SynchronousQueue<B> bs = new SynchronousQueue<>();
+    bs.addAll(iterableStream(as).map(this).toCollection());
+    return bs;
+  }
+
+
+  /**
+   * Maps this function over a PriorityBlockingQueue.
+   *
+   * @param as A PriorityBlockingQueue to map this function over.
+   * @return A new PriorityBlockingQueue with this function applied to each element.
+   */
+  default PriorityBlockingQueue<B> mapJ(final PriorityBlockingQueue<A> as) {
+    return new PriorityBlockingQueue<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a LinkedBlockingQueue.
+   *
+   * @param as A LinkedBlockingQueue to map this function over.
+   * @return A new LinkedBlockingQueue with this function applied to each element.
+   */
+  default LinkedBlockingQueue<B> mapJ(final LinkedBlockingQueue<A> as) {
+    return new LinkedBlockingQueue<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a CopyOnWriteArraySet.
+   *
+   * @param as A CopyOnWriteArraySet to map this function over.
+   * @return A new CopyOnWriteArraySet with this function applied to each element.
+   */
+  default CopyOnWriteArraySet<B> mapJ(final CopyOnWriteArraySet<A> as) {
+    return new CopyOnWriteArraySet<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a CopyOnWriteArrayList.
+   *
+   * @param as A CopyOnWriteArrayList to map this function over.
+   * @return A new CopyOnWriteArrayList with this function applied to each element.
+   */
+  default CopyOnWriteArrayList<B> mapJ(final CopyOnWriteArrayList<A> as) {
+    return new CopyOnWriteArrayList<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a ConcurrentLinkedQueue.
+   *
+   * @param as A ConcurrentLinkedQueue to map this function over.
+   * @return A new ConcurrentLinkedQueue with this function applied to each element.
+   */
+  default ConcurrentLinkedQueue<B> mapJ(final ConcurrentLinkedQueue<A> as) {
+    return new ConcurrentLinkedQueue<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over an ArrayBlockingQueue.
+   *
+   * @param as An ArrayBlockingQueue to map this function over.
+   * @return A new ArrayBlockingQueue with this function applied to each element.
+   */
+  default ArrayBlockingQueue<B> mapJ(final ArrayBlockingQueue<A> as) {
+    final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<>(as.size());
+    bs.addAll(iterableStream(as).map(this).toCollection());
+    return bs;
+  }
+
+
+  /**
+   * Maps this function over a TreeSet.
+   *
+   * @param as A TreeSet to map this function over.
+   * @return A new TreeSet with this function applied to each element.
+   */
+  default TreeSet<B> mapJ(final TreeSet<A> as) {
+    return new TreeSet<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a PriorityQueue.
+   *
+   * @param as A PriorityQueue to map this function over.
+   * @return A new PriorityQueue with this function applied to each element.
+   */
+  default java.util.PriorityQueue<B> mapJ(final java.util.PriorityQueue<A> as) {
+    return new java.util.PriorityQueue<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over a LinkedList.
+   *
+   * @param as A LinkedList to map this function over.
+   * @return A new LinkedList with this function applied to each element.
+   */
+  default LinkedList<B> mapJ(final LinkedList<A> as) {
+    return new LinkedList<>(iterableStream(as).map(this).toCollection());
+  }
+
+  /**
+   * Maps this function over an ArrayList.
+   *
+   * @param as An ArrayList to map this function over.
+   * @return A new ArrayList with this function applied to each element.
+   */
+  default ArrayList<B> mapJ(final ArrayList<A> as) {
+    return new ArrayList<>(iterableStream(as).map(this).toCollection());
+  }
+
+  default <C> F<A, C> map(F<B, C> f) {
+    return f.o(this);
+  }
+
+  default <C> F<C, B> contramap(F<C, A> f) {
+    return o(f);
+  }
+
+  /**
+   * Both map (with g) and contramap (with f) the target function. (Profunctor pattern)
+   */
+  default <C, D> F<C, D> dimap(F<C, A> f, F<B, D> g) {
+    return c -> g.f(f(f.f(c)));
+  }
+
+
 }
diff --git a/core/src/main/java/fj/F1Functions.java b/core/src/main/java/fj/F1Functions.java
deleted file mode 100644
index 00bdf515..00000000
--- a/core/src/main/java/fj/F1Functions.java
+++ /dev/null
@@ -1,687 +0,0 @@
-package fj;
-
-import fj.control.parallel.Actor;
-import fj.control.parallel.Promise;
-import fj.control.parallel.Strategy;
-import fj.data.*;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.PriorityQueue;
-import java.util.TreeSet;
-import java.util.concurrent.*;
-
-import static fj.data.Option.some;
-import static fj.data.Stream.iterableStream;
-import static fj.data.Zipper.fromStream;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F1Functions {
-
-
-    private F1Functions() {
-    }
-
-    /**
-     * Function composition
-     *
-     * @param g A function to compose with this one.
-     * @return The composed function such that this function is applied last.
-     */
-    public static <A, B, C> F<C, B> o(final F<A, B> f, final F<C, A> g) {
-        return c -> f.f(g.f(c));
-    }
-
-    /**
-     * First-class function composition
-     *
-     * @return A function that composes this function with another.
-     */
-    public static <A, B,C> F<F<C, A>, F<C, B>> o(final F<A, B> f) {
-        return g -> o(f, g);
-    }
-
-    /**
-     * Function composition flipped.
-     *
-     * @param g A function with which to compose this one.
-     * @return The composed function such that this function is applied first.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B, C> F<A, C> andThen(final F<A, B> f, final F<B, C> g) {
-        return o(g, f);
-    }
-
-    /**
-     * First-class composition flipped.
-     *
-     * @return A function that invokes this function and then a given function on the result.
-     */
-    public static <A, B, C> F<F<B, C>, F<A, C>> andThen(final F<A, B> f) {
-        return g -> andThen(f, g);
-    }
-
-    /**
-     * Binds a given function across this function (Reader Monad).
-     *
-     * @param g A function that takes the return value of this function as an argument, yielding a new function.
-     * @return A function that invokes this function on its argument and then the given function on the result.
-     */
-    public static <A, B, C> F<A, C> bind(final F<A, B> f, final F<B, F<A, C>> g) {
-        return a ->  g.f(f.f(a)).f(a);
-    }
-
-    /**
-     * First-class function binding.
-     *
-     * @return A function that binds another function across this function.
-     */
-    public static <A, B, C> F<F<B, F<A, C>>, F<A, C>> bind(final F<A, B> f) {
-        return g -> bind(f, g);
-    }
-
-    /**
-     * Function application in an environment (Applicative Functor).
-     *
-     * @param g A function with the same argument type as this function, yielding a function that takes the return
-     *          value of this function.
-     * @return A new function that invokes the given function on its argument, yielding a new function that is then
-     *         applied to the result of applying this function to the argument.
-     */
-    public static <A, B, C> F<A, C> apply(final F<A, B> f, final F<A, F<B, C>> g) {
-        return a -> g.f(a).f(f.f(a));
-    }
-
-    /**
-     * First-class function application in an environment.
-     *
-     * @return A function that applies a given function within the environment of this function.
-     */
-    public static <A, B, C> F<F<A, F<B, C>>, F<A, C>> apply(final F<A, B> f) {
-        return g -> apply(f, g);
-    }
-
-    /**
-     * Applies this function over the arguments of another function.
-     *
-     * @param g The function over whose arguments to apply this function.
-     * @return A new function that invokes this function on its arguments before invoking the given function.
-     */
-    public static <A, B, C> F<A, F<A, C>> on(final F<A, B> f, final F<B, F<B, C>> g) {
-        return a1 -> a2 -> g.f(f.f(a1)).f(f.f(a2));
-    }
-
-
-
-    /**
-     * Applies this function over the arguments of another function.
-     *
-     * @return A function that applies this function over the arguments of another function.
-     */
-    public static <A, B, C> F<F<B, F<B, C>>, F<A, F<A, C>>> on(final F<A, B> f) {
-        return g -> on(f, g);
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a product-1. Kleisli arrow for P1.
-     *
-     * @return This function promoted to return its result in a product-1.
-     */
-    public static <A, B> F<A, P1<B>> lazy(final F<A, B> f) {
-       return a -> P.lazy(() -> f.f(a));
-    }
-
-    /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument to return a lazy value.
-     */
-    public static <A, B> P1<B> f(final F<A, B> f, final A a) {
-        return P.lazy(() -> f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over a product-1.
-     *
-     * @return This function promoted to map over a product-1.
-     */
-    public static <A, B> F<P1<A>, P1<B>> mapP1(final F<A, B> f) {
-        return p -> p.map(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result in an Option. Kleisli arrow for Option.
-     *
-     * @return This function promoted to return its result in an Option.
-     */
-    public static <A, B> F<A, Option<B>> optionK(final F<A, B> f) {
-        return a -> some(f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over an optional value.
-     *
-     * @return This function promoted to map over an optional value.
-     */
-    public static <A, B> F<Option<A>, Option<B>> mapOption(final F<A, B> f) {
-        return o -> o.map(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a List. Kleisli arrow for List.
-     *
-     * @return This function promoted to return its result in a List.
-     */
-    public static <A, B> F<A, List<B>> listK(final F<A, B> f) {
-        return a -> List.single(f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over a List.
-     *
-     * @return This function promoted to map over a List.
-     */
-    public static <A, B> F<List<A>, List<B>> mapList(final F<A, B> f) {
-        return x -> x.map(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a Stream. Kleisli arrow for Stream.
-     *
-     * @return This function promoted to return its result in a Stream.
-     */
-    public static <A, B> F<A, Stream<B>> streamK(final F<A, B> f) {
-        return a -> Stream.single(f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over a Stream.
-     *
-     * @return This function promoted to map over a Stream.
-     */
-    public static <A, B> F<Stream<A>, Stream<B>> mapStream(final F<A, B> f) {
-        return x -> x.map(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a Array. Kleisli arrow for Array.
-     *
-     * @return This function promoted to return its result in a Array.
-     */
-    public static <A, B> F<A, Array<B>> arrayK(final F<A, B> f) {
-        return a -> Array.single(f.f(a));
-
-    }
-
-    /**
-     * Promotes this function to map over a Array.
-     *
-     * @return This function promoted to map over a Array.
-     */
-    public static <A, B> F<Array<A>, Array<B>> mapArray(final F<A, B> f) {
-        return x -> x.map(f);
-    }
-
-    /**
-     * Returns a function that contramaps over a given actor.
-     *
-     * @return A function that contramaps over a given actor.
-     */
-    public static <A, B> F<Actor<B>, Actor<A>> contramapActor(final F<A, B> f) {
-        return a -> a.contramap(f);
-    }
-
-    /**
-     * Promotes this function to a concurrent function that returns a Promise of a value.
-     *
-     * @param s A parallel strategy for concurrent execution.
-     * @return A concurrent function that returns a Promise of a value.
-     */
-    public static <A, B> F<A, Promise<B>> promiseK(final F<A, B> f, final Strategy<Unit> s) {
-        return Promise.promise(s, f);
-    }
-
-    /**
-     * Promotes this function to map over a Promise.
-     *
-     * @return This function promoted to map over Promises.
-     */
-    public static <A, B> F<Promise<A>, Promise<B>> mapPromise(final F<A, B> f) {
-        return p -> p.fmap(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the left side of an Either.
-     * Kleisli arrow for the Either left projection.
-     *
-     * @return This function promoted to return its result on the left side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B, C> F<A, Either<B, C>> eitherLeftK(final F<A, B> f) {
-        return o(Either.left_(), f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the right side of an Either.
-     * Kleisli arrow for the Either right projection.
-     *
-     * @return This function promoted to return its result on the right side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B, C> F<A, Either<C, B>> eitherRightK(final F<A, B> f) {
-        return o(Either.right_(), f);
-    }
-
-    /**
-     * Promotes this function to map over the left side of an Either.
-     *
-     * @return This function promoted to map over the left side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B, X> F<Either<A, X>, Either<B, X>> mapLeft(final F<A, B> f) {
-        return Either.<A, X, B>leftMap_().f(f);
-    }
-
-    /**
-     * Promotes this function to map over the right side of an Either.
-     *
-     * @return This function promoted to map over the right side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B, X> F<Either<X, A>, Either<X, B>> mapRight(final F<A, B> f) {
-        return Either.<X, A, B>rightMap_().f(f);
-    }
-
-    /**
-     * Returns a function that returns the left side of a given Either, or this function applied to the right side.
-     *
-     * @return a function that returns the left side of a given Either, or this function applied to the right side.
-     */
-    public static <A, B> F<Either<B, A>, B> onLeft(final F<A, B> f) {
-        return e -> e.left().on(f);
-    }
-
-    /**
-     * Returns a function that returns the right side of a given Either, or this function applied to the left side.
-     *
-     * @return a function that returns the right side of a given Either, or this function applied to the left side.
-     */
-    public static <A, B> F<Either<A, B>, B> onRight(final F<A, B> f) {
-        return e -> e.right().on(f);
-    }
-
-    /**
-     * Promotes this function to return its value in an Iterable.
-     *
-     * @return This function promoted to return its value in an Iterable.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B> F<A, IterableW<B>> iterableK(final F<A, B> f) {
-        return IterableW.<A, B>arrow().f(f);
-    }
-
-    /**
-     * Promotes this function to map over Iterables.
-     *
-     * @return This function promoted to map over Iterables.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B> F<Iterable<A>, IterableW<B>> mapIterable(final F<A, B> f) {
-        return o(IterableW.<A, B>map().f(f), IterableW.wrap());
-    }
-
-    /**
-     * Promotes this function to return its value in a NonEmptyList.
-     *
-     * @return This function promoted to return its value in a NonEmptyList.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B> F<A, NonEmptyList<B>> nelK(final F<A, B> f) {
-        return o(NonEmptyList.nel(), f);
-    }
-
-    /**
-     * Promotes this function to map over a NonEmptyList.
-     *
-     * @return This function promoted to map over a NonEmptyList.
-     */
-    public static <A, B> F<NonEmptyList<A>, NonEmptyList<B>> mapNel(final F<A, B> f) {
-        return list -> list.map(f);
-    }
-
-    /**
-     * Promotes this function to return its value in a Set.
-     *
-     * @param o An order for the set.
-     * @return This function promoted to return its value in a Set.
-     */
-    public static <A, B> F<A, Set<B>> setK(final F<A, B> f, final Ord<B> o
-    ) {
-        return a -> Set.single(o, f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over a Set.
-     *
-     * @param o An order for the resulting set.
-     * @return This function promoted to map over a Set.
-     */
-    public static <A, B> F<Set<A>, Set<B>> mapSet(final F<A, B> f, final Ord<B> o) {
-        return s -> s.map(o, f);
-    }
-
-    /**
-     * Promotes this function to return its value in a Tree.
-     *
-     * @return This function promoted to return its value in a Tree.
-     */
-    public static <A, B> F<A, Tree<B>> treeK(final F<A, B> f) {
-        return a -> Tree.leaf(f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over a Tree.
-     *
-     * @return This function promoted to map over a Tree.
-     */
-    @SuppressWarnings("unchecked")
-    public static <A, B> F<Tree<A>, Tree<B>> mapTree(final F<A, B> f) {
-        return Tree.<A, B>fmap_().f(f);
-    }
-
-    /**
-     * Returns a function that maps this function over a tree and folds it with the given monoid.
-     *
-     * @param m The monoid with which to fold the mapped tree.
-     * @return a function that maps this function over a tree and folds it with the given monoid.
-     */
-    public static <A, B> F<Tree<A>, B> foldMapTree(final F<A, B> f, final Monoid<B> m) {
-        return Tree.foldMap_(f, m);
-    }
-
-    /**
-     * Promotes this function to return its value in a TreeZipper.
-     *
-     * @return This function promoted to return its value in a TreeZipper.
-     */
-    public static <A, B> F<A, TreeZipper<B>> treeZipperK(final F<A, B> f) {
-        return andThen(treeK(f), TreeZipper.fromTree());
-    }
-
-    /**
-     * Promotes this function to map over a TreeZipper.
-     *
-     * @return This function promoted to map over a TreeZipper.
-     */
-    public static <A, B> F<TreeZipper<A>, TreeZipper<B>> mapTreeZipper(final F<A, B> f) {
-        return (z) -> z.map(f);
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the failure side of a Validation.
-     * Kleisli arrow for the Validation failure projection.
-     *
-     * @return This function promoted to return its result on the failure side of a Validation.
-     */
-    public static <A, B, C> F<A, Validation<B, C>> failK(final F<A, B> f) {
-        return a -> Validation.fail(f.f(a));
-
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the success side of an Validation.
-     * Kleisli arrow for the Validation success projection.
-     *
-     * @return This function promoted to return its result on the success side of an Validation.
-     */
-    public static <A, B, C> F<A, Validation<C, B>> successK(final F<A, B> f) {
-        return a -> Validation.success(f.f(a));
-    }
-
-    /**
-     * Promotes this function to map over the failure side of a Validation.
-     *
-     * @return This function promoted to map over the failure side of a Validation.
-     */
-    public static <A, B, X> F<Validation<A, X>, Validation<B, X>> mapFail(final F<A, B> f) {
-        return v -> v.f().map(f);
-    }
-
-    /**
-     * Promotes this function to map over the success side of a Validation.
-     *
-     * @return This function promoted to map over the success side of a Validation.
-     */
-    public static <A, B, X> F<Validation<X, A>, Validation<X, B>> mapSuccess(final F<A, B> f) {
-        return v -> v.map(f);
-    }
-
-    /**
-     * Returns a function that returns the failure side of a given Validation,
-     * or this function applied to the success side.
-     *
-     * @return a function that returns the failure side of a given Validation,
-     *         or this function applied to the success side.
-     */
-    public static <A, B> F<Validation<B, A>, B> onFail(final F<A, B> f) {
-        return v -> v.f().on(f);
-    }
-
-    /**
-     * Returns a function that returns the success side of a given Validation,
-     * or this function applied to the failure side.
-     *
-     * @return a function that returns the success side of a given Validation,
-     *         or this function applied to the failure side.
-     */
-    public static <A, B> F<Validation<A, B>, B> onSuccess(final F<A, B> f) {
-        return v -> v.on(f);
-    }
-
-    /**
-     * Promotes this function to return its value in a Zipper.
-     *
-     * @return This function promoted to return its value in a Zipper.
-     */
-    public static <A, B> F<A, Zipper<B>> zipperK(final F<A, B> f) {
-        return andThen(streamK(f), s -> fromStream(s).some());
-    }
-
-    /**
-     * Promotes this function to map over a Zipper.
-     *
-     * @return This function promoted to map over a Zipper.
-     */
-    public static <A, B> F<Zipper<A>, Zipper<B>> mapZipper(final F<A, B> f) {
-        return z -> z.map(f);
-    }
-
-    /**
-     * Promotes this function to map over an Equal as a contravariant functor.
-     *
-     * @return This function promoted to map over an Equal as a contravariant functor.
-     */
-    public static <A, B> F<Equal<B>, Equal<A>> contramapEqual(final F<A, B> f) {
-        return e -> e.contramap(f);
-    }
-
-    /**
-     * Promotes this function to map over a Hash as a contravariant functor.
-     *
-     * @return This function promoted to map over a Hash as a contravariant functor.
-     */
-    public static <A, B> F<Hash<B>, Hash<A>> contramapHash(final F<A, B> f) {
-        return h -> h.contramap(f);
-    }
-
-    /**
-     * Promotes this function to map over a Show as a contravariant functor.
-     *
-     * @return This function promoted to map over a Show as a contravariant functor.
-     */
-    public static <A, B> F<Show<B>, Show<A>> contramapShow(final F<A, B> f) {
-        return s -> s.contramap(f);
-    }
-
-    /**
-     * Promotes this function to map over the first element of a pair.
-     *
-     * @return This function promoted to map over the first element of a pair.
-     */
-    public static <A, B, C> F<P2<A, C>, P2<B, C>> mapFst(final F<A, B> f) {
-        return P2.map1_(f);
-    }
-
-    /**
-     * Promotes this function to map over the second element of a pair.
-     *
-     * @return This function promoted to map over the second element of a pair.
-     */
-    public static <A, B, C> F<P2<C, A>, P2<C, B>> mapSnd(final F<A, B> f) {
-        return P2.map2_(f);
-    }
-
-    /**
-     * Promotes this function to map over both elements of a pair.
-     *
-     * @return This function promoted to map over both elements of a pair.
-     */
-    public static <A, B> F<P2<A, A>, P2<B, B>> mapBoth(final F<A, B> f) {
-        return p2 -> P2.map(f, p2);
-    }
-
-    /**
-     * Maps this function over a SynchronousQueue.
-     *
-     * @param as A SynchronousQueue to map this function over.
-     * @return A new SynchronousQueue with this function applied to each element.
-     */
-    public static <A, B> SynchronousQueue<B> mapJ(final F<A, B> f, final SynchronousQueue<A> as) {
-        final SynchronousQueue<B> bs = new SynchronousQueue<>();
-        bs.addAll(iterableStream(as).map(f).toCollection());
-        return bs;
-    }
-
-
-    /**
-     * Maps this function over a PriorityBlockingQueue.
-     *
-     * @param as A PriorityBlockingQueue to map this function over.
-     * @return A new PriorityBlockingQueue with this function applied to each element.
-     */
-    public static <A, B> PriorityBlockingQueue<B> mapJ(final F<A, B> f, final PriorityBlockingQueue<A> as) {
-        return new PriorityBlockingQueue<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a LinkedBlockingQueue.
-     *
-     * @param as A LinkedBlockingQueue to map this function over.
-     * @return A new LinkedBlockingQueue with this function applied to each element.
-     */
-    public static <A, B> LinkedBlockingQueue<B> mapJ(final F<A, B> f, final LinkedBlockingQueue<A> as) {
-        return new LinkedBlockingQueue<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a CopyOnWriteArraySet.
-     *
-     * @param as A CopyOnWriteArraySet to map this function over.
-     * @return A new CopyOnWriteArraySet with this function applied to each element.
-     */
-    public static <A, B> CopyOnWriteArraySet<B> mapJ(final F<A, B> f, final CopyOnWriteArraySet<A> as) {
-        return new CopyOnWriteArraySet<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a CopyOnWriteArrayList.
-     *
-     * @param as A CopyOnWriteArrayList to map this function over.
-     * @return A new CopyOnWriteArrayList with this function applied to each element.
-     */
-    public static <A, B> CopyOnWriteArrayList<B> mapJ(final F<A, B> f, final CopyOnWriteArrayList<A> as) {
-        return new CopyOnWriteArrayList<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a ConcurrentLinkedQueue.
-     *
-     * @param as A ConcurrentLinkedQueue to map this function over.
-     * @return A new ConcurrentLinkedQueue with this function applied to each element.
-     */
-    public static <A, B> ConcurrentLinkedQueue<B> mapJ(final F<A, B> f, final ConcurrentLinkedQueue<A> as) {
-        return new ConcurrentLinkedQueue<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over an ArrayBlockingQueue.
-     *
-     * @param as An ArrayBlockingQueue to map this function over.
-     * @return A new ArrayBlockingQueue with this function applied to each element.
-     */
-    public static <A, B> ArrayBlockingQueue<B> mapJ(final F<A, B> f, final ArrayBlockingQueue<A> as) {
-        final ArrayBlockingQueue<B> bs = new ArrayBlockingQueue<>(as.size());
-        bs.addAll(iterableStream(as).map(f).toCollection());
-        return bs;
-    }
-
-
-    /**
-     * Maps this function over a TreeSet.
-     *
-     * @param as A TreeSet to map this function over.
-     * @return A new TreeSet with this function applied to each element.
-     */
-    public static <A, B> TreeSet<B> mapJ(final F<A, B> f, final TreeSet<A> as) {
-        return new TreeSet<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a PriorityQueue.
-     *
-     * @param as A PriorityQueue to map this function over.
-     * @return A new PriorityQueue with this function applied to each element.
-     */
-    public static <A, B> PriorityQueue<B> mapJ(final F<A, B> f, final PriorityQueue<A> as) {
-        return new PriorityQueue<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over a LinkedList.
-     *
-     * @param as A LinkedList to map this function over.
-     * @return A new LinkedList with this function applied to each element.
-     */
-    public static <A, B> LinkedList<B> mapJ(final F<A, B> f, final LinkedList<A> as) {
-        return new LinkedList<>(iterableStream(as).map(f).toCollection());
-    }
-
-    /**
-     * Maps this function over an ArrayList.
-     *
-     * @param as An ArrayList to map this function over.
-     * @return A new ArrayList with this function applied to each element.
-     */
-    public static <A, B> ArrayList<B> mapJ(final F<A, B> f, final ArrayList<A> as) {
-        return new ArrayList<>(iterableStream(as).map(f).toCollection());
-    }
-
-    public static <A, B, C> F<A, C> map(F<A, B> target, F<B, C> f) {
-        return o(f, target);
-    }
-
-    public static <A, B, C> F<C, B> contramap(F<A, B> target, F<C, A> f) {
-        return o(target, f);
-    }
-
-    /**
-     * Both map (with g) and contramap (with f) the target function. (Profunctor pattern)
-     */
-    public static <A, B, C, D> F<C, D> dimap(F<A, B> target, F<C, A> f, F<B, D> g) {
-        return c -> g.f(target.f(f.f(c)));
-    }
-
-}
diff --git a/core/src/main/java/fj/F1W.java b/core/src/main/java/fj/F1W.java
deleted file mode 100644
index 611c9e01..00000000
--- a/core/src/main/java/fj/F1W.java
+++ /dev/null
@@ -1,687 +0,0 @@
-package fj;
-
-import fj.control.parallel.Actor;
-import fj.control.parallel.Promise;
-import fj.control.parallel.Strategy;
-import fj.data.*;
-
-import java.util.ArrayList;
-import java.util.LinkedList;
-import java.util.PriorityQueue;
-import java.util.TreeSet;
-import java.util.concurrent.*;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F1W<A, B> implements F<A, B> {
-
-    /**
-     * Function composition
-     *
-     * @param g A function to compose with this one.
-     * @return The composed function such that this function is applied last.
-     */
-    public final <C> F1W<C, B> o(final F<C, A> g) {
-        return lift(F1Functions.o(this, g));
-    }
-
-    /**
-     * First-class function composition
-     *
-     * @return A function that composes this function with another.
-     */
-    public final <C> F1W<F<C, A>, F<C, B>> o() {
-        return lift(F1Functions.o(this));
-    }
-
-    /**
-     * Function composition flipped.
-     *
-     * @param g A function with which to compose this one.
-     * @return The composed function such that this function is applied first.
-     */
-    @SuppressWarnings("unchecked")
-    public final <C> F1W<A, C> andThen(final F<B, C> g) {
-        return lift(F1Functions.andThen(this, g));
-    }
-
-    /**
-     * First-class composition flipped.
-     *
-     * @return A function that invokes this function and then a given function on the result.
-     */
-    public final <C> F1W<F<B, C>, F<A, C>> andThen() {
-        return lift( F1Functions.andThen(this));
-    }
-
-    /**
-     * Binds a given function across this function (Reader Monad).
-     *
-     * @param g A function that takes the return value of this function as an argument, yielding a new function.
-     * @return A function that invokes this function on its argument and then the given function on the result.
-     */
-    public final <C> F1W<A, C> bind(final F<B, F<A, C>> g) {
-        return lift(F1Functions.bind(this, g));
-    }
-
-
-    /**
-     * First-class function binding.
-     *
-     * @return A function that binds another function across this function.
-     */
-    public final <C> F1W<F<B, F<A, C>>, F<A, C>> bind() {
-        return lift(F1Functions.bind(this));
-    }
-
-    /**
-     * Function application in an environment (Applicative Functor).
-     *
-     * @param g A function with the same argument type as this function, yielding a function that takes the return
-     *          value of this function.
-     * @return A new function that invokes the given function on its argument, yielding a new function that is then
-     *         applied to the result of applying this function to the argument.
-     */
-    public final <C> F1W<A, C> apply(final F<A, F<B, C>> g) {
-        return lift(F1Functions.apply(this, g));
-    }
-
-
-    /**
-     * First-class function application in an environment.
-     *
-     * @return A function that applies a given function within the environment of this function.
-     */
-    public final <C> F1W<F<A, F<B, C>>, F<A, C>> apply() {
-        return lift(F1Functions.apply(this));
-    }
-
-    /**
-     * Applies this function over the arguments of another function.
-     *
-     * @param g The function over whose arguments to apply this function.
-     * @return A new function that invokes this function on its arguments before invoking the given function.
-     */
-    public final <C> F1W<A, F<A, C>> on(final F<B, F<B, C>> g) {
-        return lift(F1Functions.on(this, g));
-    }
-
-
-    /**
-     * Applies this function over the arguments of another function.
-     *
-     * @return A function that applies this function over the arguments of another function.
-     */
-    public final <C> F1W<F<B, F<B, C>>, F<A, F<A, C>>> on() {
-        return lift(F1Functions.on(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a product-1. Kleisli arrow for P1.
-     *
-     * @return This function promoted to return its result in a product-1.
-     */
-    public final F1W<A, P1<B>> lazy() {
-        return lift(F1Functions.lazy(this));
-    }
-
-
-    /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument to return a lazy value.
-     */
-    public final P1<B> lazy(final A a) {
-        return F1Functions.f(this, a);
-    }
-
-    /**
-     * Promotes this function to map over a product-1.
-     *
-     * @return This function promoted to map over a product-1.
-     */
-    public final F1W<P1<A>, P1<B>> mapP1() {
-        return lift(F1Functions.mapP1(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result in an Option. Kleisli arrow for Option.
-     *
-     * @return This function promoted to return its result in an Option.
-     */
-    public final F1W<A, Option<B>> optionK() {
-        return lift(F1Functions.optionK(this));
-    }
-
-
-    /**
-     * Promotes this function to map over an optional value.
-     *
-     * @return This function promoted to map over an optional value.
-     */
-    public final F1W<Option<A>, Option<B>> mapOption() {
-        return lift(F1Functions.mapOption(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a List. Kleisli arrow for List.
-     *
-     * @return This function promoted to return its result in a List.
-     */
-    public final F1W<A, List<B>> listK() {
-        return lift( F1Functions.listK(this));
-    }
-
-    /**
-     * Promotes this function to map over a List.
-     *
-     * @return This function promoted to map over a List.
-     */
-    public final F1W<List<A>, List<B>> mapList() {
-        return lift(F1Functions.mapList(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a Stream. Kleisli arrow for Stream.
-     *
-     * @return This function promoted to return its result in a Stream.
-     */
-    public final F1W<A, Stream<B>> streamK() {
-        return lift(F1Functions.streamK(this));
-    }
-
-    /**
-     * Promotes this function to map over a Stream.
-     *
-     * @return This function promoted to map over a Stream.
-     */
-    public final F1W<Stream<A>, Stream<B>> mapStream() {
-        return lift(F1Functions.mapStream(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result in a Array. Kleisli arrow for Array.
-     *
-     * @return This function promoted to return its result in a Array.
-     */
-    public final F1W<A, Array<B>> arrayK() {
-        return lift(F1Functions.arrayK(this));
-
-    }
-
-    /**
-     * Promotes this function to map over a Array.
-     *
-     * @return This function promoted to map over a Array.
-     */
-    public final F1W<Array<A>, Array<B>> mapArray() {
-        return lift(F1Functions.mapArray(this));
-    }
-
-    /**
-     * Returns a function that contramaps over a given actor.
-     *
-     * @return A function that contramaps over a given actor.
-     */
-    public final F1W<Actor<B>, Actor<A>> contramapActor() {
-        return lift(F1Functions.contramapActor(this));
-    }
-
-    /**
-     * Promotes this function to a concurrent function that returns a Promise of a value.
-     *
-     * @param s A parallel strategy for concurrent execution.
-     * @return A concurrent function that returns a Promise of a value.
-     */
-    public final F1W<A, Promise<B>> promiseK(final Strategy<Unit> s) {
-        return lift(F1Functions.promiseK(this, s));
-    }
-
-    /**
-     * Promotes this function to map over a Promise.
-     *
-     * @return This function promoted to map over Promises.
-     */
-    public final F1W<Promise<A>, Promise<B>> mapPromise() {
-        return lift(F1Functions.mapPromise(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the left side of an Either.
-     * Kleisli arrow for the Either left projection.
-     *
-     * @return This function promoted to return its result on the left side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public final <C> F1W<A, Either<B, C>> eitherLeftK() {
-        return lift(F1Functions.eitherLeftK(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the right side of an Either.
-     * Kleisli arrow for the Either right projection.
-     *
-     * @return This function promoted to return its result on the right side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public final <C> F1W<A, Either<C, B>> eitherRightK() {
-        return lift(F1Functions.eitherRightK(this));
-    }
-
-    /**
-     * Promotes this function to map over the left side of an Either.
-     *
-     * @return This function promoted to map over the left side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public final <X> F1W<Either<A, X>, Either<B, X>> mapLeft() {
-        return lift(F1Functions.mapLeft(this));
-    }
-
-    /**
-     * Promotes this function to map over the right side of an Either.
-     *
-     * @return This function promoted to map over the right side of an Either.
-     */
-    @SuppressWarnings("unchecked")
-    public final <X> F1W<Either<X, A>, Either<X, B>> mapRight() {
-        return lift(F1Functions.mapRight(this));
-    }
-
-    /**
-     * Returns a function that returns the left side of a given Either, or this function applied to the right side.
-     *
-     * @return a function that returns the left side of a given Either, or this function applied to the right side.
-     */
-    public final F1W<Either<B, A>, B> onLeft() {
-        return lift(F1Functions.onLeft(this));
-    }
-
-    /**
-     * Returns a function that returns the right side of a given Either, or this function applied to the left side.
-     *
-     * @return a function that returns the right side of a given Either, or this function applied to the left side.
-     */
-    public final F1W<Either<A, B>, B> onRight() {
-        return lift(F1Functions.onRight(this));
-    }
-
-    /**
-     * Promotes this function to return its value in an Iterable.
-     *
-     * @return This function promoted to return its value in an Iterable.
-     */
-    @SuppressWarnings("unchecked")
-    public final F1W<A, IterableW<B>> iterableK() {
-        return lift( F1Functions.iterableK(this));
-    }
-
-    /**
-     * Promotes this function to map over Iterables.
-     *
-     * @return This function promoted to map over Iterables.
-     */
-    @SuppressWarnings("unchecked")
-    public final F1W<Iterable<A>, IterableW<B>> mapIterable() {
-        return lift( F1Functions.mapIterable(this));
-    }
-
-    /**
-     * Promotes this function to return its value in a NonEmptyList.
-     *
-     * @return This function promoted to return its value in a NonEmptyList.
-     */
-    @SuppressWarnings("unchecked")
-    public final F1W<A, NonEmptyList<B>> nelK() {
-        return lift(F1Functions.nelK(this));
-    }
-
-    /**
-     * Promotes this function to map over a NonEmptyList.
-     *
-     * @return This function promoted to map over a NonEmptyList.
-     */
-    public final F1W<NonEmptyList<A>, NonEmptyList<B>> mapNel() {
-        return lift(F1Functions.mapNel(this));
-    }
-
-    /**
-     * Promotes this function to return its value in a Set.
-     *
-     * @param o An order for the set.
-     * @return This function promoted to return its value in a Set.
-     */
-    public final F1W<A, Set<B>> setK(final Ord<B> o) {
-        return lift(F1Functions.setK(this, o));
-    }
-
-    /**
-     * Promotes this function to map over a Set.
-     *
-     * @param o An order for the resulting set.
-     * @return This function promoted to map over a Set.
-     */
-    public final F1W<Set<A>, Set<B>> mapSet(final Ord<B> o) {
-        return lift(F1Functions.mapSet(this, o));
-    }
-
-    /**
-     * Promotes this function to return its value in a Tree.
-     *
-     * @return This function promoted to return its value in a Tree.
-     */
-    public final F1W<A, Tree<B>> treeK() {
-        return lift(F1Functions.treeK(this));
-    }
-
-    /**
-     * Promotes this function to map over a Tree.
-     *
-     * @return This function promoted to map over a Tree.
-     */
-    @SuppressWarnings("unchecked")
-    public final F1W<Tree<A>, Tree<B>> mapTree() {
-        return lift(F1Functions.mapTree(this));
-    }
-
-    /**
-     * Returns a function that maps this function over a tree and folds it with the given monoid.
-     *
-     * @param m The monoid with which to fold the mapped tree.
-     * @return a function that maps this function over a tree and folds it with the given monoid.
-     */
-    public final F1W<Tree<A>, B> foldMapTree(final Monoid<B> m) {
-        return lift(F1Functions.foldMapTree(this, m));
-    }
-
-    /**
-     * Promotes this function to return its value in a TreeZipper.
-     *
-     * @return This function promoted to return its value in a TreeZipper.
-     */
-    public final F1W<A, TreeZipper<B>> treeZipperK() {
-        return lift(F1Functions.treeZipperK(this));
-    }
-
-    /**
-     * Promotes this function to map over a TreeZipper.
-     *
-     * @return This function promoted to map over a TreeZipper.
-     */
-    public final F1W<TreeZipper<A>, TreeZipper<B>> mapTreeZipper() {
-        return lift(F1Functions.mapTreeZipper(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the failure side of a Validation.
-     * Kleisli arrow for the Validation failure projection.
-     *
-     * @return This function promoted to return its result on the failure side of a Validation.
-     */
-    public final <C> F1W<A, Validation<B, C>> failK() {
-        return lift(F1Functions.failK(this));
-    }
-
-    /**
-     * Promotes this function so that it returns its result on the success side of an Validation.
-     * Kleisli arrow for the Validation success projection.
-     *
-     * @return This function promoted to return its result on the success side of an Validation.
-     */
-    public final <C> F1W<A, Validation<C, B>> successK() {
-        return lift( F1Functions.successK(this));
-    }
-
-    /**
-     * Promotes this function to map over the failure side of a Validation.
-     *
-     * @return This function promoted to map over the failure side of a Validation.
-     */
-    public final <X> F1W<Validation<A, X>, Validation<B, X>> mapFail() {
-        return lift(F1Functions.mapFail(this));
-    }
-
-    /**
-     * Promotes this function to map over the success side of a Validation.
-     *
-     * @return This function promoted to map over the success side of a Validation.
-     */
-    public final <X> F1W<Validation<X, A>, Validation<X, B>> mapSuccess() {
-        return lift(F1Functions.mapSuccess(this));
-    }
-
-    /**
-     * Returns a function that returns the failure side of a given Validation,
-     * or this function applied to the success side.
-     *
-     * @return a function that returns the failure side of a given Validation,
-     *         or this function applied to the success side.
-     */
-    public final F1W<Validation<B, A>, B> onFail() {
-        return lift(F1Functions.onFail(this));
-    }
-
-    /**
-     * Returns a function that returns the success side of a given Validation,
-     * or this function applied to the failure side.
-     *
-     * @return a function that returns the success side of a given Validation,
-     *         or this function applied to the failure side.
-     */
-    public final F1W<Validation<A, B>, B> onSuccess() {
-        return lift(F1Functions.onSuccess(this));
-    }
-
-    /**
-     * Promotes this function to return its value in a Zipper.
-     *
-     * @return This function promoted to return its value in a Zipper.
-     */
-    public final F1W<A, Zipper<B>> zipperK() {
-        return lift(F1Functions.zipperK(this));
-    }
-
-    /**
-     * Promotes this function to map over a Zipper.
-     *
-     * @return This function promoted to map over a Zipper.
-     */
-    public final F1W<Zipper<A>, Zipper<B>> mapZipper() {
-        return lift(F1Functions.mapZipper(this));
-    }
-
-    /**
-     * Promotes this function to map over an Equal as a contravariant functor.
-     *
-     * @return This function promoted to map over an Equal as a contravariant functor.
-     */
-    public final F1W<Equal<B>, Equal<A>> contramapEqual() {
-        return lift(F1Functions.contramapEqual(this));
-    }
-
-    /**
-     * Promotes this function to map over a Hash as a contravariant functor.
-     *
-     * @return This function promoted to map over a Hash as a contravariant functor.
-     */
-    public final F1W<Hash<B>, Hash<A>> contramapHash() {
-        return lift(F1Functions.contramapHash(this));
-    }
-
-    /**
-     * Promotes this function to map over a Show as a contravariant functor.
-     *
-     * @return This function promoted to map over a Show as a contravariant functor.
-     */
-    public final F1W<Show<B>, Show<A>> contramapShow() {
-        return lift(F1Functions.contramapShow(this));
-    }
-
-    /**
-     * Promotes this function to map over the first element of a pair.
-     *
-     * @return This function promoted to map over the first element of a pair.
-     */
-    public final <C> F1W<P2<A, C>, P2<B, C>> mapFst() {
-        return lift(F1Functions.mapFst(this));
-    }
-
-    /**
-     * Promotes this function to map over the second element of a pair.
-     *
-     * @return This function promoted to map over the second element of a pair.
-     */
-    public final <C> F1W<P2<C, A>, P2<C, B>> mapSnd() {
-        return lift(F1Functions.mapSnd(this));
-    }
-
-    /**
-     * Promotes this function to map over both elements of a pair.
-     *
-     * @return This function promoted to map over both elements of a pair.
-     */
-    public final F1W<P2<A, A>, P2<B, B>> mapBoth() {
-        return lift(F1Functions.mapBoth(this));
-    }
-
-    /**
-     * Maps this function over a SynchronousQueue.
-     *
-     * @param as A SynchronousQueue to map this function over.
-     * @return A new SynchronousQueue with this function applied to each element.
-     */
-    public final SynchronousQueue<B> mapJ(final SynchronousQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-
-    /**
-     * Maps this function over a PriorityBlockingQueue.
-     *
-     * @param as A PriorityBlockingQueue to map this function over.
-     * @return A new PriorityBlockingQueue with this function applied to each element.
-     */
-    public final PriorityBlockingQueue<B> mapJ(final PriorityBlockingQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a LinkedBlockingQueue.
-     *
-     * @param as A LinkedBlockingQueue to map this function over.
-     * @return A new LinkedBlockingQueue with this function applied to each element.
-     */
-    public final LinkedBlockingQueue<B> mapJ(final LinkedBlockingQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a CopyOnWriteArraySet.
-     *
-     * @param as A CopyOnWriteArraySet to map this function over.
-     * @return A new CopyOnWriteArraySet with this function applied to each element.
-     */
-    public final CopyOnWriteArraySet<B> mapJ(final CopyOnWriteArraySet<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a CopyOnWriteArrayList.
-     *
-     * @param as A CopyOnWriteArrayList to map this function over.
-     * @return A new CopyOnWriteArrayList with this function applied to each element.
-     */
-    public final CopyOnWriteArrayList<B> mapJ(final CopyOnWriteArrayList<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a ConcurrentLinkedQueue.
-     *
-     * @param as A ConcurrentLinkedQueue to map this function over.
-     * @return A new ConcurrentLinkedQueue with this function applied to each element.
-     */
-    public final ConcurrentLinkedQueue<B> mapJ(final ConcurrentLinkedQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over an ArrayBlockingQueue.
-     *
-     * @param as An ArrayBlockingQueue to map this function over.
-     * @return A new ArrayBlockingQueue with this function applied to each element.
-     */
-    public final ArrayBlockingQueue<B> mapJ(final ArrayBlockingQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-
-    /**
-     * Maps this function over a TreeSet.
-     *
-     * @param as A TreeSet to map this function over.
-     * @return A new TreeSet with this function applied to each element.
-     */
-    public final TreeSet<B> mapJ(final TreeSet<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a PriorityQueue.
-     *
-     * @param as A PriorityQueue to map this function over.
-     * @return A new PriorityQueue with this function applied to each element.
-     */
-    public final PriorityQueue<B> mapJ(final PriorityQueue<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over a LinkedList.
-     *
-     * @param as A LinkedList to map this function over.
-     * @return A new LinkedList with this function applied to each element.
-     */
-    public final LinkedList<B> mapJ(final LinkedList<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    /**
-     * Maps this function over an ArrayList.
-     *
-     * @param as An ArrayList to map this function over.
-     * @return A new ArrayList with this function applied to each element.
-     */
-    public final ArrayList<B> mapJ(final ArrayList<A> as) {
-        return F1Functions.mapJ(this, as);
-    }
-
-    public final <C> F1W<A, C> map(F<B, C> f) {
-        return lift(F1Functions.map(this, f));
-    }
-
-    public final <C> F1W<C, B> contramap(F<C, A> f) {
-        return lift(F1Functions.contramap(this, f));
-    }
-
-    public static class F1WFunc<A, B> extends F1W<A, B> {
-        final F<A, B> func;
-        public F1WFunc(F<A, B> f) {
-            func = f;
-        }
-
-        @Override
-        public final B f(A a) {
-            return func.f(a);
-        }
-    }
-
-    /**
-     * Lifts the function into the fully featured function wrapper
-     */
-    public static <A, B> F1W<A, B> lift(final F<A, B> f) {
-        return new F1WFunc<>(f);
-    }
-}
diff --git a/core/src/main/java/fj/F2.java b/core/src/main/java/fj/F2.java
index 63555fd5..ba0e6f2f 100644
--- a/core/src/main/java/fj/F2.java
+++ b/core/src/main/java/fj/F2.java
@@ -1,12 +1,24 @@
 package fj;
 
+import fj.control.parallel.Promise;
+import fj.data.*;
+
+import java.util.function.BiFunction;
+
+import static fj.P.p;
+import static fj.data.IterableW.wrap;
+import static fj.data.Set.iterableSet;
+import static fj.data.Tree.node;
+import static fj.data.TreeZipper.treeZipper;
+import static fj.data.Zipper.zipper;
+
 /**
  * A transformation function of arity-2 from <code>A</code> and <code>B</code> to <code>C</code>.
  * This type can be represented using the Java 7 closure syntax.
  *
  * @version %build.number%
  */
-public interface F2<A, B, C> {
+public interface F2<A, B, C> extends BiFunction<A, B, C> {
   /**
    * Transform <code>A</code> and <code>B</code> to <code>C</code>.
    *
@@ -16,4 +28,264 @@ public interface F2<A, B, C> {
    */
   C f(A a, B b);
 
+  default C apply(A a, B b) {
+    return f(a, b);
+  }
+
+  /**
+   * Partial application.
+   *
+   * @param a The <code>A</code> to which to apply this function.
+   * @return The function partially applied to the given argument.
+   */
+  default F<B, C> f(final A a) {
+    return b -> f(a, b);
+  }
+
+  /**
+   * Curries this wrapped function to a wrapped function of arity-1 that returns another wrapped function.
+   *
+   * @return a wrapped function of arity-1 that returns another wrapped function.
+   */
+  default F<A, F<B, C>> curry() {
+    return a -> b -> f(a, b);
+  }
+
+  /**
+   * Flips the arguments of this function.
+   *
+   * @return A new function with the arguments of this function flipped.
+   */
+  default F2<B, A, C> flip() {
+    return (b, a) -> f(a, b);
+  }
+
+  /**
+   * Uncurries this function to a function on tuples.
+   *
+   * @return A new function that calls this function with the elements of a given tuple.
+   */
+  default F<P2<A, B>, C> tuple() {
+    return p -> f(p._1(), p._2());
+  }
+
+  /**
+   * Promotes this function to a function on Arrays.
+   *
+   * @return This function promoted to transform Arrays.
+   */
+  default F2<Array<A>, Array<B>, Array<C>> arrayM() {
+    return (a, b) -> a.bind(b, curry());
+  }
+
+  /**
+   * Promotes this function to a function on Promises.
+   *
+   * @return This function promoted to transform Promises.
+   */
+  default F2<Promise<A>, Promise<B>, Promise<C>> promiseM() {
+    return (a, b) -> a.bind(b, curry());
+  }
+
+  /**
+   * Promotes this function to a function on Iterables.
+   *
+   * @return This function promoted to transform Iterables.
+   */
+  default F2<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
+    return (a, b) -> IterableW.liftM2(curry()).f(a).f(b);
+  }
+
+  /**
+   * Promotes this function to a function on Lists.
+   *
+   * @return This function promoted to transform Lists.
+   */
+  default F2<List<A>, List<B>, List<C>> listM() {
+    return (a, b) -> List.liftM2(curry()).f(a).f(b);
+  }
+
+  /**
+   * Promotes this function to a function on non-empty lists.
+   *
+   * @return This function promoted to transform non-empty lists.
+   */
+  default F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
+    return (as, bs) -> NonEmptyList.fromList(as.toList().bind(bs.toList(), this)).some();
+  }
+
+  /**
+   * Promotes this function to a function on Options.
+   *
+   * @return This function promoted to transform Options.
+   */
+  default F2<Option<A>, Option<B>, Option<C>> optionM() {
+    return (a, b) -> Option.liftM2(curry()).f(a).f(b);
+  }
+
+  /**
+   * Promotes this function to a function on Sets.
+   *
+   * @param o An ordering for the result of the promoted function.
+   * @return This function promoted to transform Sets.
+   */
+  default F2<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
+    return (as, bs) -> {
+      Set<C> cs = Set.empty(o);
+      for (final A a : as)
+        for (final B b : bs)
+          cs = cs.insert(f(a, b));
+      return cs;
+    };
+  }
+
+  /**
+   * Promotes this function to a function on Streams.
+   *
+   * @return This function promoted to transform Streams.
+   */
+  default F2<Stream<A>, Stream<B>, Stream<C>> streamM() {
+    return (as, bs) -> as.bind(bs, this);
+  }
+
+  /**
+   * Promotes this function to a function on Trees.
+   *
+   * @return This function promoted to transform Trees.
+   */
+  default F2<Tree<A>, Tree<B>, Tree<C>> treeM() {
+    F2<A, B, C> outer = this;
+    return new F2<Tree<A>, Tree<B>, Tree<C>>() {
+      public Tree<C> f(final Tree<A> as, final Tree<B> bs) {
+        final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
+        return node(outer.f(as.root(), bs.root()), P.lazy(() -> self.streamM().f(as.subForest()._1(), bs.subForest()._1())));
+      }
+    };
+  }
+
+  /**
+   * Promotes this function to zip two arrays, applying the function lock-step over both Arrays.
+   *
+   * @return A function that zips two arrays with this function.
+   */
+  default F2<Array<A>, Array<B>, Array<C>> zipArrayM() {
+    return (as, bs) -> as.zipWith(bs, this);
+  }
+
+  /**
+   * Promotes this function to zip two iterables, applying the function lock-step over both iterables.
+   *
+   * @return A function that zips two iterables with this function.
+   */
+  default F2<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
+    return (as, bs) -> wrap(as).zipWith(bs, this);
+  }
+
+  /**
+   * Promotes this function to zip two lists, applying the function lock-step over both lists.
+   *
+   * @return A function that zips two lists with this function.
+   */
+  default F2<List<A>, List<B>, List<C>> zipListM() {
+    return (as, bs) -> as.zipWith(bs, this);
+  }
+
+
+  /**
+   * Promotes this function to zip two streams, applying the function lock-step over both streams.
+   *
+   * @return A function that zips two streams with this function.
+   */
+  default F2<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
+    return (as, bs) -> as.zipWith(bs, this);
+  }
+
+  /**
+   * Promotes this function to zip two non-empty lists, applying the function lock-step over both lists.
+   *
+   * @return A function that zips two non-empty lists with this function.
+   */
+  default F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
+    return (as, bs) -> NonEmptyList.fromList(as.toList().zipWith(bs.toList(), this)).some();
+  }
+
+  /**
+   * Promotes this function to zip two sets, applying the function lock-step over both sets.
+   *
+   * @param o An ordering for the resulting set.
+   * @return A function that zips two sets with this function.
+   */
+  default F2<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
+    return (as, bs) -> iterableSet(o, as.toStream().zipWith(bs.toStream(), this));
+  }
+
+  /**
+   * Promotes this function to zip two trees, applying the function lock-step over both trees.
+   * The structure of the resulting tree is the structural intersection of the two trees.
+   *
+   * @return A function that zips two trees with this function.
+   */
+  default F2<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
+    F2<A, B, C> outer = this;
+    return new F2<Tree<A>, Tree<B>, Tree<C>>() {
+      public Tree<C> f(final Tree<A> ta, final Tree<B> tb) {
+        final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
+        return node(outer.f(ta.root(), tb.root()), P.lazy(() -> self.zipStreamM().f(ta.subForest()._1(), tb.subForest()._1())));
+      }
+    };
+  }
+
+  /**
+   * Promotes this function to zip two zippers, applying the function lock-step over both zippers in both directions.
+   * The structure of the resulting zipper is the structural intersection of the two zippers.
+   *
+   * @return A function that zips two zippers with this function.
+   */
+  default F2<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
+    return (ta, tb) -> {
+      final F2<Stream<A>, Stream<B>, Stream<C>> sf = this.zipStreamM();
+      return zipper(sf.f(ta.lefts(), tb.lefts()), f(ta.focus(), tb.focus()), sf.f(ta.rights(), tb.rights()));
+    };
+  }
+
+  /**
+   * Promotes this function to zip two TreeZippers, applying the function lock-step over both zippers in all directions.
+   * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
+   *
+   * @return A function that zips two TreeZippers with this function.
+   */
+  default F2<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM() {
+    F2<A, B, C> outer = this;
+    return (ta, tb) -> {
+      final F2<Stream<Tree<A>>, Stream<Tree<B>>, Stream<Tree<C>>> sf = outer.treeM().zipStreamM();
+      F2<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>, P3<Stream<Tree<B>>, B, Stream<Tree<B>>>, P3<Stream<Tree<C>>, C, Stream<Tree<C>>>> g =
+              (pa, pb) -> p(outer.treeM().zipStreamM().f(pa._1(), pb._1()), outer.f(pa._2(), pb._2()),
+                      outer.treeM().zipStreamM().f(pa._3(), pb._3()));
+      final
+      F2<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>,
+              Stream<P3<Stream<Tree<B>>, B, Stream<Tree<B>>>>,
+              Stream<P3<Stream<Tree<C>>, C, Stream<Tree<C>>>>>
+              pf = g.zipStreamM();
+      return treeZipper(outer.treeM().f(ta.p()._1(), tb.p()._1()), sf.f(ta.lefts(), tb.lefts()),
+              sf.f(ta.rights(), tb.rights()), pf.f(ta.p()._4(), tb.p()._4()));
+    };
+  }
+
+  default <Z> F2<Z, B, C> contramapFirst(F<Z, A> f) {
+    return (z, b) -> f(f.f(z), b);
+  }
+
+  default <Z> F2<A, Z, C> contramapSecond(F<Z, B> f) {
+    return (a, z) -> f(a, f.f(z));
+  }
+
+  default <X, Y> F2<X, Y, C> contramap(F<X, A> f, F<Y, B> g) {
+    return contramapFirst(f).contramapSecond(g);
+  }
+
+  default <Z> F2<A, B, Z> map(F<C, Z> f) {
+    return (a, b) -> f.f(f(a, b));
+  }
+
+
 }
diff --git a/core/src/main/java/fj/F2Functions.java b/core/src/main/java/fj/F2Functions.java
deleted file mode 100644
index f69e02ed..00000000
--- a/core/src/main/java/fj/F2Functions.java
+++ /dev/null
@@ -1,273 +0,0 @@
-package fj;
-
-import fj.control.parallel.Promise;
-import fj.data.*;
-
-import static fj.P.p;
-import static fj.data.IterableW.wrap;
-import static fj.data.Set.iterableSet;
-import static fj.data.Tree.node;
-import static fj.data.TreeZipper.treeZipper;
-import static fj.data.Zipper.zipper;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F2Functions {
-
-
-  private F2Functions() {
-  }
-
-  /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument.
-     */
-  public static <A, B, C> F<B, C> f(final F2<A, B, C> f, final A a) {
-        return b -> f.f(a, b);
-    }
-
-    /**
-     * Curries this wrapped function to a wrapped function of arity-1 that returns another wrapped function.
-     *
-     * @return a wrapped function of arity-1 that returns another wrapped function.
-     */
-    public static <A, B, C> F<A, F<B, C>> curry(final F2<A, B, C> f) {
-        return a -> b -> f.f(a, b);
-    }
-
-    /**
-     * Flips the arguments of this function.
-     *
-     * @return A new function with the arguments of this function flipped.
-     */
-    public static <A, B, C> F2<B, A, C> flip(final F2<A, B, C> f) {
-        return (b, a) -> f.f(a, b);
-    }
-
-    /**
-     * Uncurries this function to a function on tuples.
-     *
-     * @return A new function that calls this function with the elements of a given tuple.
-     */
-    public static <A, B, C> F<P2<A, B>, C> tuple(final F2<A, B, C> f) {
-        return p -> f.f(p._1(), p._2());
-    }
-
-    /**
-     * Promotes this function to a function on Arrays.
-     *
-     * @return This function promoted to transform Arrays.
-     */
-    public static <A, B, C> F2<Array<A>, Array<B>, Array<C>> arrayM(final F2<A, B, C> f) {
-        return (a, b) -> a.bind(b, curry(f));
-    }
-
-    /**
-     * Promotes this function to a function on Promises.
-     *
-     * @return This function promoted to transform Promises.
-     */
-    public static <A, B, C> F2<Promise<A>, Promise<B>, Promise<C>> promiseM(final F2<A, B, C> f) {
-        return (a, b) -> a.bind(b, curry(f));
-    }
-
-    /**
-     * Promotes this function to a function on Iterables.
-     *
-     * @return This function promoted to transform Iterables.
-     */
-    public static <A, B, C> F2<Iterable<A>, Iterable<B>, IterableW<C>> iterableM(final F2<A, B, C> f) {
-        return (a, b) -> IterableW.liftM2(curry(f)).f(a).f(b);
-    }
-
-    /**
-     * Promotes this function to a function on Lists.
-     *
-     * @return This function promoted to transform Lists.
-     */
-    public static <A, B, C> F2<List<A>, List<B>, List<C>> listM(final F2<A, B, C> f) {
-        return (a, b) -> List.liftM2(curry(f)).f(a).f(b);
-    }
-
-    /**
-     * Promotes this function to a function on non-empty lists.
-     *
-     * @return This function promoted to transform non-empty lists.
-     */
-    public static <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM(final F2<A, B, C> f) {
-        return (as, bs) -> NonEmptyList.fromList(as.toList().bind(bs.toList(), f)).some();
-    }
-
-    /**
-     * Promotes this function to a function on Options.
-     *
-     * @return This function promoted to transform Options.
-     */
-    public static <A, B, C> F2<Option<A>, Option<B>, Option<C>> optionM(final F2<A, B, C> f) {
-        return (a, b) -> Option.liftM2(curry(f)).f(a).f(b);
-    }
-
-    /**
-     * Promotes this function to a function on Sets.
-     *
-     * @param o An ordering for the result of the promoted function.
-     * @return This function promoted to transform Sets.
-     */
-    public static <A, B, C> F2<Set<A>, Set<B>, Set<C>> setM(final F2<A, B, C> f, final Ord<C> o) {
-        return (as, bs) -> {
-            Set<C> cs = Set.empty(o);
-            for (final A a : as)
-                for (final B b : bs)
-                    cs = cs.insert(f.f(a, b));
-            return cs;
-        };
-    }
-
-    /**
-     * Promotes this function to a function on Streams.
-     *
-     * @return This function promoted to transform Streams.
-     */
-    public static <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> streamM(final F2<A, B, C> f) {
-        return (as, bs) -> as.bind(bs, f);
-    }
-
-    /**
-     * Promotes this function to a function on Trees.
-     *
-     * @return This function promoted to transform Trees.
-     */
-    public static <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> treeM(final F2<A, B, C> f) {
-        return new F2<Tree<A>, Tree<B>, Tree<C>>() {
-            public Tree<C> f(final Tree<A> as, final Tree<B> bs) {
-                final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
-                return node(f.f(as.root(), bs.root()), P.lazy(() -> streamM(self).f(as.subForest()._1(), bs.subForest()._1())));
-            }
-        };
-    }
-
-    /**
-     * Promotes this function to zip two arrays, applying the function lock-step over both Arrays.
-     *
-     * @return A function that zips two arrays with this function.
-     */
-    public static <A, B, C> F2<Array<A>, Array<B>, Array<C>> zipArrayM(final F2<A, B, C> f) {
-        return (as, bs) -> as.zipWith(bs, f);
-    }
-
-    /**
-     * Promotes this function to zip two iterables, applying the function lock-step over both iterables.
-     *
-     * @return A function that zips two iterables with this function.
-     */
-    public static <A, B, C> F2<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM(final F2<A, B, C> f) {
-        return (as, bs) -> wrap(as).zipWith(bs, f);
-    }
-
-    /**
-     * Promotes this function to zip two lists, applying the function lock-step over both lists.
-     *
-     * @return A function that zips two lists with this function.
-     */
-    public static <A, B, C> F2<List<A>, List<B>, List<C>> zipListM(final F2<A, B, C> f) {
-        return (as, bs) -> as.zipWith(bs, f);
-    }
-
-
-    /**
-     * Promotes this function to zip two streams, applying the function lock-step over both streams.
-     *
-     * @return A function that zips two streams with this function.
-     */
-    public static <A, B, C> F2<Stream<A>, Stream<B>, Stream<C>> zipStreamM(final F2<A, B, C> f) {
-        return (as, bs) -> as.zipWith(bs, f);
-    }
-
-    /**
-     * Promotes this function to zip two non-empty lists, applying the function lock-step over both lists.
-     *
-     * @return A function that zips two non-empty lists with this function.
-     */
-    public static <A, B, C> F2<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM(final F2<A, B, C> f) {
-        return (as, bs) -> NonEmptyList.fromList(as.toList().zipWith(bs.toList(), f)).some();
-    }
-
-    /**
-     * Promotes this function to zip two sets, applying the function lock-step over both sets.
-     *
-     * @param o An ordering for the resulting set.
-     * @return A function that zips two sets with this function.
-     */
-    public static <A, B, C> F2<Set<A>, Set<B>, Set<C>> zipSetM(final F2<A, B, C> f, final Ord<C> o) {
-        return (as, bs) -> iterableSet(o, as.toStream().zipWith(bs.toStream(), f));
-    }
-
-    /**
-     * Promotes this function to zip two trees, applying the function lock-step over both trees.
-     * The structure of the resulting tree is the structural intersection of the two trees.
-     *
-     * @return A function that zips two trees with this function.
-     */
-    public static <A, B, C> F2<Tree<A>, Tree<B>, Tree<C>> zipTreeM(final F2<A, B, C> f) {
-        return new F2<Tree<A>, Tree<B>, Tree<C>>() {
-            public Tree<C> f(final Tree<A> ta, final Tree<B> tb) {
-                final F2<Tree<A>, Tree<B>, Tree<C>> self = this;
-                return node(f.f(ta.root(), tb.root()), P.lazy(() -> zipStreamM(self).f(ta.subForest()._1(), tb.subForest()._1())));
-            }
-        };
-    }
-
-    /**
-     * Promotes this function to zip two zippers, applying the function lock-step over both zippers in both directions.
-     * The structure of the resulting zipper is the structural intersection of the two zippers.
-     *
-     * @return A function that zips two zippers with this function.
-     */
-    public static <A, B, C> F2<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM(final F2<A, B, C> f) {
-        return (ta, tb) -> {
-            final F2<Stream<A>, Stream<B>, Stream<C>> sf = zipStreamM(f);
-            return zipper(sf.f(ta.lefts(), tb.lefts()), f.f(ta.focus(), tb.focus()), sf.f(ta.rights(), tb.rights()));
-        };
-    }
-
-    /**
-     * Promotes this function to zip two TreeZippers, applying the function lock-step over both zippers in all directions.
-     * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
-     *
-     * @return A function that zips two TreeZippers with this function.
-     */
-    public static <A, B, C> F2<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM(final F2<A, B, C> f) {
-        return (ta, tb) -> {
-            final F2<Stream<Tree<A>>, Stream<Tree<B>>, Stream<Tree<C>>> sf = zipStreamM(treeM(f));
-            final
-            F2<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>,
-                    Stream<P3<Stream<Tree<B>>, B, Stream<Tree<B>>>>,
-                    Stream<P3<Stream<Tree<C>>, C, Stream<Tree<C>>>>>
-                    pf =
-                    zipStreamM((pa, pb) -> p(zipStreamM(treeM(f)).f(pa._1(), pb._1()), f.f(pa._2(), pb._2()),
-                            zipStreamM(treeM(f)).f(pa._3(), pb._3())));
-            return treeZipper(treeM(f).f(ta.p()._1(), tb.p()._1()), sf.f(ta.lefts(), tb.lefts()),
-                    sf.f(ta.rights(), tb.rights()), pf.f(ta.p()._4(), tb.p()._4()));
-        };
-    }
-
-    public static <A, B, C, Z> F2<Z, B, C> contramapFirst(F2<A, B, C> target, F<Z, A> f) {
-        return (z, b) -> target.f(f.f(z), b);
-    }
-
-    public static <A, B, C, Z> F2<A, Z, C> contramapSecond(F2<A, B, C> target, F<Z, B> f) {
-        return (a, z) -> target.f(a, f.f(z));
-    }
-
-    public static <A, B, C, X, Y> F2<X, Y, C> contramap(F2<A, B, C> target, F<X, A> f, F<Y, B> g) {
-        return contramapSecond(contramapFirst(target, f), g);
-    }
-
-    public static <A, B, C, Z> F2<A, B, Z> map(F2<A, B, C> target, F<C, Z> f) {
-        return (a, b) -> f.f(target.f(a, b));
-    }
-
-}
diff --git a/core/src/main/java/fj/F2W.java b/core/src/main/java/fj/F2W.java
deleted file mode 100644
index 1f35855a..00000000
--- a/core/src/main/java/fj/F2W.java
+++ /dev/null
@@ -1,254 +0,0 @@
-package fj;
-
-import fj.control.parallel.Promise;
-import fj.data.*;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F2W<A, B, C> implements F2<A, B, C> {
-
-    /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument.
-     */
-    public final F1W<B, C> f(final A a) {
-        return F1W.lift(F2Functions.f(this, a));
-    }
-
-    /**
-     * Curries this wrapped function to a wrapped function of arity-1 that returns another wrapped function.
-     *
-     * @return a wrapped function of arity-1 that returns another wrapped function.
-     */
-    public final F1W<A, F<B, C>> curry() {
-        return F1W.lift(F2Functions.curry(this));
-    }
-
-    /**
-     * Flips the arguments of this function.
-     *
-     * @return A new function with the arguments of this function flipped.
-     */
-    public final F2W<B, A, C> flip() {
-        return lift(F2Functions.flip(this));
-    }
-
-    /**
-     * Uncurries this function to a function on tuples.
-     *
-     * @return A new function that calls this function with the elements of a given tuple.
-     */
-    public final F1W<P2<A, B>, C> tuple() {
-        return F1W.lift(F2Functions.tuple(this));
-    }
-
-    /**
-     * Promotes this function to a function on Arrays.
-     *
-     * @return This function promoted to transform Arrays.
-     */
-    public final F2W<Array<A>, Array<B>, Array<C>> arrayM() {
-        return lift(F2Functions.arrayM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Promises.
-     *
-     * @return This function promoted to transform Promises.
-     */
-    public final F2W<Promise<A>, Promise<B>, Promise<C>> promiseM() {
-        return lift(F2Functions.promiseM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Iterables.
-     *
-     * @return This function promoted to transform Iterables.
-     */
-    public final F2W<Iterable<A>, Iterable<B>, IterableW<C>> iterableM() {
-        return lift(F2Functions.iterableM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Lists.
-     *
-     * @return This function promoted to transform Lists.
-     */
-    public final F2W<List<A>, List<B>, List<C>> listM() {
-        return lift(F2Functions.listM(this));
-    }
-
-    /**
-     * Promotes this function to a function on non-empty lists.
-     *
-     * @return This function promoted to transform non-empty lists.
-     */
-    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> nelM() {
-        return lift(F2Functions.nelM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Options.
-     *
-     * @return This function promoted to transform Options.
-     */
-    public final F2W<Option<A>, Option<B>, Option<C>> optionM() {
-        return lift(F2Functions.optionM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Sets.
-     *
-     * @param o An ordering for the result of the promoted function.
-     * @return This function promoted to transform Sets.
-     */
-    public final F2W<Set<A>, Set<B>, Set<C>> setM(final Ord<C> o) {
-        return lift(F2Functions.setM(this, o));
-    }
-
-    /**
-     * Promotes this function to a function on Streams.
-     *
-     * @return This function promoted to transform Streams.
-     */
-    public final F2W<Stream<A>, Stream<B>, Stream<C>> streamM() {
-        return lift(F2Functions.streamM(this));
-    }
-
-    /**
-     * Promotes this function to a function on Trees.
-     *
-     * @return This function promoted to transform Trees.
-     */
-    public final F2W<Tree<A>, Tree<B>, Tree<C>> treeM() {
-        return lift(F2Functions.treeM(this));
-    }
-
-    /**
-     * Promotes this function to zip two arrays, applying the function lock-step over both Arrays.
-     *
-     * @return A function that zips two arrays with this function.
-     */
-    public final F2W<Array<A>, Array<B>, Array<C>> zipArrayM() {
-        return lift(F2Functions.zipArrayM(this));
-    }
-
-    /**
-     * Promotes this function to zip two iterables, applying the function lock-step over both iterables.
-     *
-     * @return A function that zips two iterables with this function.
-     */
-    public final F2W<Iterable<A>, Iterable<B>, Iterable<C>> zipIterableM() {
-        return lift(F2Functions.zipIterableM(this));
-    }
-
-    /**
-     * Promotes this function to zip two lists, applying the function lock-step over both lists.
-     *
-     * @return A function that zips two lists with this function.
-     */
-    public final F2W<List<A>, List<B>, List<C>> zipListM() {
-        return lift(F2Functions.zipListM(this));
-    }
-
-
-    /**
-     * Promotes this function to zip two streams, applying the function lock-step over both streams.
-     *
-     * @return A function that zips two streams with this function.
-     */
-    public final F2W<Stream<A>, Stream<B>, Stream<C>> zipStreamM() {
-        return lift(F2Functions.zipStreamM(this));
-    }
-
-    /**
-     * Promotes this function to zip two non-empty lists, applying the function lock-step over both lists.
-     *
-     * @return A function that zips two non-empty lists with this function.
-     */
-    public final F2W<NonEmptyList<A>, NonEmptyList<B>, NonEmptyList<C>> zipNelM() {
-        return lift(F2Functions.zipNelM(this));
-    }
-
-    /**
-     * Promotes this function to zip two sets, applying the function lock-step over both sets.
-     *
-     * @param o An ordering for the resulting set.
-     * @return A function that zips two sets with this function.
-     */
-    public final F2W<Set<A>, Set<B>, Set<C>> zipSetM(final Ord<C> o) {
-        return lift(F2Functions.zipSetM(this, o));
-    }
-
-    /**
-     * Promotes this function to zip two trees, applying the function lock-step over both trees.
-     * The structure of the resulting tree is the structural intersection of the two trees.
-     *
-     * @return A function that zips two trees with this function.
-     */
-    public final F2W<Tree<A>, Tree<B>, Tree<C>> zipTreeM() {
-        return lift(F2Functions.zipTreeM(this));
-    }
-
-    /**
-     * Promotes this function to zip two zippers, applying the function lock-step over both zippers in both directions.
-     * The structure of the resulting zipper is the structural intersection of the two zippers.
-     *
-     * @return A function that zips two zippers with this function.
-     */
-    public final F2W<Zipper<A>, Zipper<B>, Zipper<C>> zipZipperM() {
-        return lift(F2Functions.zipZipperM(this));
-    }
-
-    /**
-     * Promotes this function to zip two TreeZippers, applying the function lock-step over both zippers in all directions.
-     * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
-     *
-     * @return A function that zips two TreeZippers with this function.
-     */
-    public final F2W<TreeZipper<A>, TreeZipper<B>, TreeZipper<C>> zipTreeZipperM() {
-        return lift(F2Functions.zipTreeZipperM(this));
-    }
-
-    public final <Z> F2W<Z, B, C> contramapFirst(F<Z, A> f) {
-        return lift(F2Functions.contramapFirst(this, f));
-    }
-
-    public final <Z> F2W<A, Z, C> contramapSecond(F<Z, B> f) {
-        return lift(F2Functions.contramapSecond(this, f));
-    }
-
-    public final <X, Y> F2W<X, Y, C> contramap(F<X, A> f, F<Y, B> g) {
-        return lift(F2Functions.contramap(this, f, g));
-    }
-
-    public final <Z> F2W<A, B, Z> map(F<C, Z> f) {
-        return lift(F2Functions.map(this, f));
-    }
-
-
-    public static class F2WFunc<A, B, C> extends F2W<A, B, C> {
-        final F2<A, B, C> func;
-        public F2WFunc(F2<A, B, C> f) {
-            func = f;
-        }
-
-        @Override
-        public final C f(A a, B b) {
-            return func.f(a, b);
-        }
-    }
-
-    /**
-     * Lifts the function into the fully featured function wrapper
-     */
-    public static <A, B, C> F2W<A, B, C> lift(final F2<A, B, C> f) {
-        return new F2WFunc<>(f);
-    }
-
-
-
-}
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 490dc9d6..96d24b82 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -1,7 +1,5 @@
 package fj;
 
-import static fj.F1Functions.dimap;
-
 import fj.data.*;
 
 import static fj.Function.*;
@@ -146,7 +144,7 @@ public B append(B a1, B a2) {
 
       @Override
       public F<B, B> prepend(B b) {
-        return dimap(def.prepend(g.f(b)), g, f);
+        return def.prepend(g.f(b)).dimap(g, f);
       }
 
       @Override
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 5e627403..420b820b 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -108,7 +108,7 @@ public final <B, C> P1<C> bind(final P1<B> cb, final F<A, F<B, C>> f) {
 	 * Binds the given function to the values in the given P1s with a final join.
 	 */
 	public final <B, C> P1<C> bind(final P1<B> cb, final F2<A, B, C> f) {
-		return bind(cb, F2W.lift(f).curry());
+		return bind(cb, f.curry());
 	}
 
     /**
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index b434a0da..841b356e 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -166,7 +166,7 @@ public final <C> Stream<C> sequenceW(final Stream<F<P2<A, B>, C>> fs) {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P2.<A, B>__1()).f(this);
+    return P2.<A, B>__1().lazy().f(this);
   }
 
   /**
@@ -175,7 +175,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P2.<A, B>__2()).f(this);
+    return P2.<A, B>__2().lazy().f(this);
   }
 
   /**
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index fe980059..6e08a0ba 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -101,7 +101,7 @@ public X _3() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P3.<A, B, C>__1()).f(this);
+    return P3.<A, B, C>__1().lazy().f(this);
   }
 
   /**
@@ -110,7 +110,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P3.<A, B, C>__2()).f(this);
+    return P3.<A, B, C>__2().lazy().f(this);
   }
 
   /**
@@ -119,7 +119,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P3.<A, B, C>__3()).f(this);
+    return P3.<A, B, C>__3().lazy().f(this);
   }
 
 
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index a7bf8167..4fa2ef8c 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -146,7 +146,7 @@ public X _4() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P4.<A, B, C, D>__1()).f(this);
+    return P4.<A, B, C, D>__1().lazy().f(this);
   }
 
   /**
@@ -155,7 +155,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P4.<A, B, C, D>__2()).f(this);
+    return P4.<A, B, C, D>__2().lazy().f(this);
   }
 
   /**
@@ -164,7 +164,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P4.<A, B, C, D>__3()).f(this);
+    return P4.<A, B, C, D>__3().lazy().f(this);
   }
 
   /**
@@ -173,7 +173,7 @@ public final P1<C> _3_() {
    * @return the 1-product projection over the fourth element.
    */
   public final P1<D> _4_() {
-    return F1Functions.lazy(P4.<A, B, C, D>__4()).f(this);
+    return P4.<A, B, C, D>__4().lazy().f(this);
   }
 
 
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index 69262327..fabc4227 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -199,7 +199,7 @@ public X _5() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P5.<A, B, C, D, E>__1()).f(this);
+    return P5.<A, B, C, D, E>__1().lazy().f(this);
   }
 
   /**
@@ -208,7 +208,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P5.<A, B, C, D, E>__2()).f(this);
+    return P5.<A, B, C, D, E>__2().lazy().f(this);
   }
 
   /**
@@ -217,7 +217,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P5.<A, B, C, D, E>__3()).f(this);
+    return P5.<A, B, C, D, E>__3().lazy().f(this);
   }
 
   /**
@@ -226,7 +226,7 @@ public final P1<C> _3_() {
    * @return the 1-product projection over the fourth element.
    */
   public final P1<D> _4_() {
-    return F1Functions.lazy(P5.<A, B, C, D, E>__4()).f(this);
+    return P5.<A, B, C, D, E>__4().lazy().f(this);
   }
 
   /**
@@ -235,7 +235,7 @@ public final P1<D> _4_() {
    * @return the 1-product projection over the fifth element.
    */
   public final P1<E> _5_() {
-    return F1Functions.lazy(P5.<A, B, C, D, E>__5()).f(this);
+    return P5.<A, B, C, D, E>__5().lazy().f(this);
   }
 
   /**
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index fbf91948..670622c7 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -261,7 +261,7 @@ public X _6() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__1()).f(this);
+    return P6.<A, B, C, D, E, F>__1().lazy().f(this);
   }
 
   /**
@@ -270,7 +270,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__2()).f(this);
+    return P6.<A, B, C, D, E, F>__2().lazy().f(this);
   }
 
   /**
@@ -279,7 +279,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__3()).f(this);
+    return P6.<A, B, C, D, E, F>__3().lazy().f(this);
   }
 
   /**
@@ -288,7 +288,7 @@ public final P1<C> _3_() {
    * @return the 1-product projection over the fourth element.
    */
   public final P1<D> _4_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__4()).f(this);
+    return P6.<A, B, C, D, E, F>__4().lazy().f(this);
   }
 
   /**
@@ -297,7 +297,7 @@ public final P1<D> _4_() {
    * @return the 1-product projection over the fifth element.
    */
   public final P1<E> _5_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__5()).f(this);
+    return P6.<A, B, C, D, E, F>__5().lazy().f(this);
   }
 
   /**
@@ -306,7 +306,7 @@ public final P1<E> _5_() {
    * @return the 1-product projection over the sixth element.
    */
   public final P1<F> _6_() {
-    return F1Functions.lazy(P6.<A, B, C, D, E, F>__6()).f(this);
+    return P6.<A, B, C, D, E, F>__6().lazy().f(this);
   }
 
   /**
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index b1c67b30..6c9ac804 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -330,7 +330,7 @@ public X _7() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__1()).f(this);
+    return P7.<A, B, C, D, E, F, G>__1().lazy().f(this);
   }
 
   /**
@@ -339,7 +339,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__2()).f(this);
+    return P7.<A, B, C, D, E, F, G>__2().lazy().f(this);
   }
 
   /**
@@ -348,7 +348,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__3()).f(this);
+    return P7.<A, B, C, D, E, F, G>__3().lazy().f(this);
   }
 
   /**
@@ -357,7 +357,7 @@ public final P1<C> _3_() {
    * @return the 1-product projection over the fourth element.
    */
   public final P1<D> _4_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__4()).f(this);
+    return P7.<A, B, C, D, E, F, G>__4().lazy().f(this);
   }
 
   /**
@@ -366,7 +366,7 @@ public final P1<D> _4_() {
    * @return the 1-product projection over the fifth element.
    */
   public final P1<E> _5_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__5()).f(this);
+    return P7.<A, B, C, D, E, F, G>__5().lazy().f(this);
   }
 
   /**
@@ -375,7 +375,7 @@ public final P1<E> _5_() {
    * @return the 1-product projection over the sixth element.
    */
   public final P1<F> _6_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__6()).f(this);
+    return P7.<A, B, C, D, E, F, G>__6().lazy().f(this);
   }
 
   /**
@@ -384,7 +384,7 @@ public final P1<F> _6_() {
    * @return the 1-product projection over the seventh element.
    */
   public final P1<G> _7_() {
-    return F1Functions.lazy(P7.<A, B, C, D, E, F, G>__7()).f(this);
+    return P7.<A, B, C, D, E, F, G>__7().lazy().f(this);
   }
 
   /**
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index f15d63a1..f3902c5e 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -408,7 +408,7 @@ public X _8() {
    * @return the 1-product projection over the first element.
    */
   public final P1<A> _1_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__1()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__1().lazy().f(this);
   }
 
   /**
@@ -417,7 +417,7 @@ public final P1<A> _1_() {
    * @return the 1-product projection over the second element.
    */
   public final P1<B> _2_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__2()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__2().lazy().f(this);
   }
 
   /**
@@ -426,7 +426,7 @@ public final P1<B> _2_() {
    * @return the 1-product projection over the third element.
    */
   public final P1<C> _3_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__3()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__3().lazy().f(this);
   }
 
   /**
@@ -435,7 +435,7 @@ public final P1<C> _3_() {
    * @return the 1-product projection over the fourth element.
    */
   public final P1<D> _4_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__4()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__4().lazy().f(this);
   }
 
   /**
@@ -444,7 +444,7 @@ public final P1<D> _4_() {
    * @return the 1-product projection over the fifth element.
    */
   public final P1<E> _5_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__5()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__5().lazy().f(this);
   }
 
   /**
@@ -453,7 +453,7 @@ public final P1<E> _5_() {
    * @return the 1-product projection over the sixth element.
    */
   public final P1<F> _6_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__6()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__6().lazy().f(this);
   }
 
   /**
@@ -462,7 +462,7 @@ public final P1<F> _6_() {
    * @return the 1-product projection over the seventh element.
    */
   public final P1<G> _7_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__7()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__7().lazy().f(this);
   }
 
   /**
@@ -471,7 +471,7 @@ public final P1<G> _7_() {
    * @return the 1-product projection over the eighth element.
    */
   public final P1<H> _8_() {
-    return F1Functions.lazy(P8.<A, B, C, D, E, F, G, H>__8()).f(this);
+    return P8.<A, B, C, D, E, F, G, H>__8().lazy().f(this);
   }
 
   /**
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index ef8029b3..6fbc5fc6 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -13,13 +13,10 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
-import static fj.F1Functions.dimap;
 import static fj.Function.constant;
 import static fj.Function.identity;
 import static fj.Monoid.*;
 import static fj.data.DList.listDList;
-import static fj.data.Option.none;
-import static fj.data.Option.some;
 
 /**
  * Implementations must satisfy the law of associativity:
@@ -193,7 +190,7 @@ public B append(B a1, B a2) {
 
       @Override
       public F<B, B> prepend(B b) {
-        return dimap(def.prepend(g.f(b)), g, f);
+        return def.prepend(g.f(b)).dimap(g, f);
       }
 
       @Override
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index 47fd282b..e3b58e1c 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -171,7 +171,7 @@ public static <A> F<P1<Trampoline<A>>, Trampoline<A>> suspend_() {
    * @return A new trampoline that runs this trampoline, then applies the given function to the result.
    */
   public final <B> Trampoline<B> map(final F<A, B> f) {
-    return bind(F1Functions.o(Trampoline.pure(), f));
+    return bind(Trampoline.<B>pure().o(f));
   }
 
   /**
@@ -266,10 +266,11 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
     final Either<P1<Trampoline<B>>, B> eb = b.resume();
     for (final P1<Trampoline<A>> x : ea.left()) {
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(x.bind(y, F2Functions.curry((ta, tb) -> suspend(() -> ta.zipWith(tb, f)))));
+        F<Trampoline<A>, F<Trampoline<B>, Trampoline<C>>> z = ta -> tb -> suspend(() -> ta.zipWith(tb, f));
+        return suspend(x.bind(y, z));
       }
       for (final B y : eb.right()) {
-        return suspend(x.map(ta -> ta.map(F2Functions.f(F2Functions.flip(f), y))));
+        return suspend(x.map(ta -> ta.map(f.flip().f(y))));
       }
     }
     for (final A x : ea.right()) {
@@ -277,7 +278,7 @@ public final <B, C> Trampoline<C> zipWith(final Trampoline<B> b, final F2<A, B,
         return suspend(() -> pure(f.f(x, y)));
       }
       for (final P1<Trampoline<B>> y : eb.left()) {
-        return suspend(y.map(liftM2(F2Functions.curry(f)).f(pure(x))));
+        return suspend(y.map(liftM2(f.curry()).f(pure(x))));
       }
     }
     throw Bottom.error("Match error: Trampoline is neither done nor suspended.");
diff --git a/core/src/main/java/fj/control/parallel/ParModule.java b/core/src/main/java/fj/control/parallel/ParModule.java
index 514988aa..b9eeacbf 100644
--- a/core/src/main/java/fj/control/parallel/ParModule.java
+++ b/core/src/main/java/fj/control/parallel/ParModule.java
@@ -67,7 +67,7 @@ public <A> F<P1<A>, Promise<A>> promise() {
    *         that can be claimed in the future.
    */
   public <A, B> F<A, Promise<B>> promise(final F<A, B> f) {
-    return F1Functions.promiseK(f, strategy);
+    return f.promiseK(strategy);
   }
 
   /**
@@ -88,7 +88,7 @@ public <A, B> F<F<A, B>, F<A, Promise<B>>> promisePure() {
    *         that can be claimed in the future.
    */
   public <A, B, C> F2<A, B, Promise<C>> promise(final F2<A, B, C> f) {
-    return P2.untuple(F1Functions.promiseK(F2Functions.tuple(f), strategy));
+    return P2.untuple(f.tuple().promiseK(strategy));
   }
 
 
diff --git a/core/src/main/java/fj/data/IOFunctions.java b/core/src/main/java/fj/data/IOFunctions.java
index 2ea15dfb..9573deea 100644
--- a/core/src/main/java/fj/data/IOFunctions.java
+++ b/core/src/main/java/fj/data/IOFunctions.java
@@ -2,7 +2,6 @@
 
 import fj.F;
 import fj.F0;
-import fj.F1Functions;
 import fj.F2;
 import fj.Function;
 import fj.P;
@@ -204,7 +203,7 @@ public IO<IterV<String, A>> f(IterV<String, A> it) {
                         return i;
                     }
                     final Input<String> input = Input.el(s);
-                    final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = F1Functions.lazy(Function.apply(input));
+                    final F<F<Input<String>, IterV<String, A>>, P1<IterV<String, A>>> cont = Function.<Input<String>, IterV<String, A>>apply(input).lazy();
                     i = i.fold(done, cont)._1();
                 }
                 return i;
@@ -248,7 +247,7 @@ public IO<IterV<char[], A>> f(IterV<char[], A> it) {
                     }
                     final Input<char[]> input = Input.el(buffer);
                     final F<F<Input<char[]>, IterV<char[], A>>, P1<IterV<char[], A>>> cont =
-                        F1Functions.lazy(Function.apply(input));
+                            Function.<Input<char[]>, IterV<char[], A>>apply(input).lazy();
                     i = i.fold(done, cont)._1();
                 }
                 return i;
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index bcb03cc0..be68ed02 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -2,7 +2,6 @@
 
 import fj.F;
 import fj.F0;
-import fj.F1Functions;
 import fj.Function;
 import fj.P;
 import fj.P2;
@@ -82,7 +81,7 @@ public <Z> Z fold(final F<P2<A, Input<E>>, Z> done, final F<F<Input<E>, IterV<E,
     public final A run() {
       final F<IterV<E, A>, Option<A>> runCont =
         new F<IterV<E, A>, Option<A>>() {
-          final F<P2<A, Input<E>>, Option<A>> done = F1Functions.andThen(P2.__1(), Option.some_());
+          final F<P2<A, Input<E>>, Option<A>> done = P2.<A, Input<E>>__1().andThen(Option.some_());
           final F<F<Input<E>, IterV<E, A>>, Option<A>> cont = Function.constant(Option.none());
 
           @Override
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 422d246b..5b5fff67 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -969,7 +969,7 @@ public final <B> B foldRight(final F2<A, B, B> f, final B b) {
    * @return A Trampoline containing the final result after the right-fold reduction.
    */
   public final <B> Trampoline<B> foldRightC(final F2<A, B, B> f, final B b) {
-    return Trampoline.suspend(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(F2Functions.f(f, head())));
+    return Trampoline.suspend(() -> isEmpty() ? Trampoline.pure(b) : tail().foldRightC(f, b).map(f.f(head())));
   }
 
   /**
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index 4073476d..34c8b957 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -169,9 +169,10 @@ public <B> NonEmptyList<B> bind(final F<A, NonEmptyList<B>> f) {
    * @return a NonEmptyList of the sublists of this list.
    */
   public NonEmptyList<NonEmptyList<A>> sublists() {
+    F<Stream<A>, Option<NonEmptyList<A>>> f = s -> NonEmptyList.fromList(Conversions.<A>Stream_List().f(s));
     return fromList(
         somes(toList().toStream().substreams()
-            .map(F1Functions.o(NonEmptyList::fromList, Conversions.Stream_List())).toList())).some();
+            .map(f).toList())).some();
   }
 
   /**
diff --git a/core/src/main/java/fj/data/Reader.java b/core/src/main/java/fj/data/Reader.java
index af66c87e..9374e300 100644
--- a/core/src/main/java/fj/data/Reader.java
+++ b/core/src/main/java/fj/data/Reader.java
@@ -1,7 +1,6 @@
 package fj.data;
 
 import fj.F;
-import fj.F1Functions;
 
 /**
  * The Reader monad (also called the function monad, so equivalent to the idea of F).
@@ -32,7 +31,7 @@ public final B f(A a) {
 	}
 
 	public final <C> Reader<A, C> map(F<B, C> f) {
-		return unit(F1Functions.andThen(function, f));
+		return unit(function.andThen(f));
 	}
 
 	public final <C> Reader<A, C> andThen(F<B, C> f) {
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index 9eebb932..f430d6d2 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -127,7 +127,7 @@ public static <A> F<Tree<A>, P1<Stream<Tree<A>>>> subForest_() {
   public Stream<A> flatten() {
     final F2<Tree<A>, P1<Stream<A>>, Stream<A>> squish = new F2<Tree<A>, P1<Stream<A>>, Stream<A>>() {
       public Stream<A> f(final Tree<A> t, final P1<Stream<A>> xs) {
-        return cons(t.root(), t.subForest().map(Stream.<Tree<A>, Stream<A>>foldRight().f(F2Functions.curry(this)).f(xs._1())));
+        return cons(t.root(), t.subForest().map(Stream.<Tree<A>, Stream<A>>foldRight().f(this.curry()).f(xs._1())));
       }
     };
     return squish.f(this, P.p(Stream.nil()));
@@ -305,7 +305,7 @@ public static <A> Show<Tree<A>> show2D(final Show<A> s) {
    * @return A new tree of the results of applying the given function over this tree and the given tree, position-wise.
    */
   public <B, C> Tree<C> zipWith(final Tree<B> bs, final F2<A, B, C> f) {
-    return F2Functions.zipTreeM(f).f(this, bs);
+    return f.zipTreeM().f(this, bs);
   }
 
   /**
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index cd111d06..38607dbc 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -2,7 +2,6 @@
 
 import fj.Equal;
 import fj.F;
-import fj.F1Functions;
 import fj.Hash;
 import fj.Ord;
 import fj.P;
@@ -308,9 +307,9 @@ public TreeMap<K, V> update(final K k, final F<V, V> f, final V v) {
    *         and the optional value is the value associated with the given key if present, otherwise None.
    */
   public P3<Set<V>, Option<V>, Set<V>> split(Ord<V> ord, final K k) {
-    final F<Set<P2<K, Option<V>>>, Set<V>> getSome = F1Functions.mapSet(F1Functions.o(Option.fromSome(), P2.__2()), ord);
+    final F<Set<P2<K, Option<V>>>, Set<V>> getSome = Option.<V>fromSome().o(P2.<K, Option<V>>__2()).mapSet(ord);
     return tree.split(p(k, Option.none())).map1(getSome).map3(getSome)
-        .map2(F1Functions.o(Option.join(), F1Functions.mapOption(P2.__2())));
+        .map2(Option.<V>join().o(P2.<K, Option<V>>__2().mapOption()));
   }
 
   /**
@@ -359,7 +358,7 @@ public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
    */
   @SuppressWarnings("unchecked")
   public <W> TreeMap<K, W> map(final F<V, W> f) {
-    final F<P2<K, Option<V>>, P2<K, Option<W>>> g = compose(p2 -> p(p2._1(), p2._2()), P2.map2_(F1Functions.mapOption(f)));
+    final F<P2<K, Option<V>>, P2<K, Option<W>>> g = compose(p2 -> p(p2._1(), p2._2()), P2.map2_(f.mapOption()));
     final F<K, P2<K, Option<V>>> coord = flip(P.<K, Option<V>>p2()).f(Option.none());
     final Ord<K> o = tree.ord().contramap(coord);
     return new TreeMap<>(tree.map(TreeMap.ord(o), g));
diff --git a/core/src/main/java/fj/data/TreeZipper.java b/core/src/main/java/fj/data/TreeZipper.java
index 9ffad4f4..545238f3 100644
--- a/core/src/main/java/fj/data/TreeZipper.java
+++ b/core/src/main/java/fj/data/TreeZipper.java
@@ -1,678 +1,678 @@
-package fj.data;
-
-import fj.*;
-import fj.function.Booleans;
-
-import java.util.Iterator;
-
-import static fj.Equal.p3Equal;
-import static fj.Equal.p4Equal;
-import static fj.Equal.streamEqual;
-import static fj.Equal.treeEqual;
-import static fj.Function.compose;
-import static fj.Function.curry;
-import static fj.Function.flip;
-import static fj.Function.uncurryF2;
-import static fj.Show.p3Show;
-import static fj.Show.p4Show;
-import static fj.Show.streamShow;
-import static fj.Show.treeShow;
-import static fj.data.Option.none;
-import static fj.data.Option.some;
-import static fj.data.Stream.nil;
-import static fj.data.Stream.unfold;
-import static fj.data.Tree.node;
-import static fj.data.Tree.unfoldTree;
-
-/**
- * Provides a zipper structure for rose trees, which is a Tree supplied with a location within that tree.
- * Provides navigation, insertion, deletion, and memorization of visited locations within a tree.
- */
-public final class TreeZipper<A> implements Iterable<TreeZipper<A>> {
-
-  /**
-   * Returns an iterator of all the positions of this TreeZipper. Exists for use with the foreach syntax.
-   *
-   * @return An iterator of all the positions of this TreeZipper.
-   */
-  public Iterator<TreeZipper<A>> iterator() {
-    return positions().toTree().iterator();
-  }
-
-  private final Tree<A> tree;
-  private final Stream<Tree<A>> lefts;
-  private final Stream<Tree<A>> rights;
-  private final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents;
-
-  private TreeZipper(final Tree<A> tree,
-                     final Stream<Tree<A>> lefts,
-                     final Stream<Tree<A>> rights,
-                     final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents) {
-    this.tree = tree;
-    this.lefts = lefts;
-    this.rights = rights;
-    this.parents = parents;
-  }
-
-    @Override
-    public final boolean equals(Object other) {
-        return Equal.equals0(TreeZipper.class, this, other, () -> Equal.treeZipperEqual(Equal.anyEqual()));
-    }
-
-    @Override
-    public final int hashCode() {
-        return Hash.treeZipperHash(Hash.<A>anyHash()).hash(this);
-    }
-
-    /**
-   * Creates a new tree zipper given a currently selected tree, a forest on the left, a forest on the right,
-   * and a stream of parent contexts.
-   *
-   * @param tree    The currently selected tree.
-   * @param lefts   The selected tree's left siblings, closest first.
-   * @param rights  The selected tree's right siblings, closest first.
-   * @param parents The parent of the selected tree, and the parent's siblings.
-   * @return A new zipper with the given tree selected, and the given forests on the left and right.
-   */
-  public static <A> TreeZipper<A> treeZipper(final Tree<A> tree,
-                                             final Stream<Tree<A>> lefts,
-                                             final Stream<Tree<A>> rights,
-                                             final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents) {
-    return new TreeZipper<>(tree, lefts, rights, parents);
-  }
-
-  /**
-   * First-class constructor for tree zippers.
-   *
-   * @return A function that returns a new tree zipper, given a selected tree, left and right siblings,
-   *         and a parent context.
-   */
-  public static <A>
-  F<Tree<A>, F<Stream<Tree<A>>, F<Stream<Tree<A>>, F<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>, TreeZipper<A>>>>>
-  treeZipper() {
-    return curry(
-        TreeZipper::treeZipper);
-  }
-
-  /**
-   * Returns the product-4 representation of this zipper.
-   *
-   * @return the product-4 representation of this zipper.
-   */
-  public P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>> p() {
-    return P.p(tree, lefts, rights, parents);
-  }
-
-  /**
-   * A first-class function that returns the product-4 representation of a given zipper.
-   *
-   * @return a function that converts a given zipper to its product-4 representation.
-   */
-  public static <A>
-  F<TreeZipper<A>, P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>>> p_() {
-    return TreeZipper::p;
-  }
-
-  /**
-   * An Equal instance for tree zippers.
-   *
-   * @param e An Equal instance for tree elements.
-   * @return An Equal instance for tree zippers.
-   */
-  public static <A> Equal<TreeZipper<A>> eq(final Equal<A> e) {
-    return p4Equal(
-        treeEqual(e),
-        streamEqual(treeEqual(e)),
-        streamEqual(treeEqual(e)),
-        streamEqual(p3Equal(streamEqual(treeEqual(e)), e, streamEqual(treeEqual(e))))).contramap(TreeZipper.p_());
-  }
-
-  /**
-   * A Show instance for tree zippers.
-   *
-   * @param s A Show instance for tree elements.
-   * @return A Show instance for tree zippers.
-   */
-  public static <A> Show<TreeZipper<A>> show(final Show<A> s) {
-    return p4Show(
-        treeShow(s),
-        streamShow(treeShow(s)),
-        streamShow(treeShow(s)),
-        streamShow(p3Show(streamShow(treeShow(s)), s, streamShow(treeShow(s))))).contramap(TreeZipper.p_());
-  }
-
-  private static <A> Stream<Tree<A>> combChildren(final Stream<Tree<A>> ls,
-                                                  final Tree<A> t,
-                                                  final Stream<Tree<A>> rs) {
-    return ls.foldLeft(compose(flip(Stream.cons()), P.p1()), Stream.cons(t, P.p(rs)));
-  }
-
-  /**
-   * Navigates to the parent of the current location.
-   *
-   * @return A new tree zipper focused on the parent node of the current node,
-   *         or none if the current node is the root node.
-   */
-  public Option<TreeZipper<A>> parent() {
-    if (parents.isEmpty())
-      return none();
-    else {
-      final P3<Stream<Tree<A>>, A, Stream<Tree<A>>> p = parents.head();
-      return some(treeZipper(node(p._2(), combChildren(lefts, tree, rights)), p._1(), p._3(), parents.tail()._1()));
-    }
-  }
-
-  /**
-   * Navigates to the top-most parent of the current location.
-   *
-   * @return A new tree zipper focused on the top-most parent of the current node.
-   */
-  public TreeZipper<A> root() {
-    return parent().option(this, TreeZipper.root_());
-  }
-
-  /**
-   * A first-class version of the root function.
-   *
-   * @return A function that returns a new tree-zipper focused on the root of the given tree zipper's tree.
-   */
-  public static <A> F<TreeZipper<A>, TreeZipper<A>> root_() {
-    return TreeZipper::root;
-  }
-
-  /**
-   * Navigates to the left sibling of the current location.
-   *
-   * @return A new tree zipper focused on the left sibling of the current node,
-   *         or none if there are no siblings on the left.
-   */
-  public Option<TreeZipper<A>> left() {
-    return lefts.isEmpty() ? Option.none()
-                           : some(treeZipper(lefts.head(), lefts.tail()._1(), rights.cons(tree), parents));
-  }
-
-  /**
-   * Navigates to the right sibling of the current location.
-   *
-   * @return A new tree zipper focused on the right sibling of the current node,
-   *         or none if there are no siblings on the right.
-   */
-  public Option<TreeZipper<A>> right() {
-    return rights.isEmpty() ? Option.none()
-                            : some(treeZipper(rights.head(), lefts.cons(tree), rights.tail()._1(), parents));
-  }
-
-  /**
-   * Navigtes to the first child of the current location.
-   *
-   * @return A new tree zipper focused on the first child of the current node, or none if the node has no children.
-   */
-  public Option<TreeZipper<A>> firstChild() {
-    final Stream<Tree<A>> ts = tree.subForest()._1();
-    return ts.isEmpty() ? Option.none()
-                        : some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), downParents()));
-  }
-
-  /**
-   * Navigtes to the last child of the current location.
-   *
-   * @return A new tree zipper focused on the last child of the current node, or none if the node has no children.
-   */
-  public Option<TreeZipper<A>> lastChild() {
-    final Stream<Tree<A>> ts = tree.subForest()._1().reverse();
-    return ts.isEmpty() ? Option.none()
-                        : some(treeZipper(ts.head(), ts.tail()._1(), Stream.nil(), downParents()));
-  }
-
-  /**
-   * Navigates to the given child of the current location, starting at index 0.
-   *
-   * @param n The index of the child to which to navigate.
-   * @return An optional tree zipper focused on the child node at the given index, or none if there is no such child.
-   */
-  public Option<TreeZipper<A>> getChild(final int n) {
-    Option<TreeZipper<A>> r = none();
-    for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
-        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
-      r = some(treeZipper(lr._1().head(), lr._1().tail()._1(), lr._2(), downParents()));
-    }
-    return r;
-  }
-
-  /**
-   * Navigates to the first child of the current location, that satisfies the given predicate.
-   *
-   * @param p A predicate to be satisfied by the child node.
-   * @return An optional tree zipper focused on the first child node that satisfies the given predicate,
-   *         or none if there is no such child.
-   */
-  public Option<TreeZipper<A>> findChild(final F<Tree<A>, Boolean> p) {
-    Option<TreeZipper<A>> r = none();
-
-    final F2<Stream<Tree<A>>, Stream<Tree<A>>, Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>>> split =
-        new F2<Stream<Tree<A>>, Stream<Tree<A>>, Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>>>() {
-          public Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>> f(final Stream<Tree<A>> acc,
-                                                                         final Stream<Tree<A>> xs) {
-            return xs.isNotEmpty()
-                     ? p.f(xs.head()) ? some(P.p(acc, xs.head(), xs.tail()._1()))
-                                      : f(acc.cons(xs.head()), xs.tail()._1())
-                     : Option.none();
-          }
-        };
-
-    Stream<Tree<A>> subforest = tree.subForest()._1();
-    if (subforest.isNotEmpty()) {
-      for (final P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>> ltr
-        : split.f(Stream.nil(), subforest)) {
-        r = some(treeZipper(ltr._2(), ltr._1(), ltr._3(), downParents()));
-      }
-    }
-    return r;
-  }
-
-  private Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> downParents() {
-    return parents.cons(P.p(lefts, tree.root(), rights));
-  }
-
-  private static <A> Option<P2<Stream<A>, Stream<A>>> splitChildren(final Stream<A> acc,
-                                                                    final Stream<A> xs,
-                                                                    final int n) {
-    return n == 0 ? some(P.p(acc, xs))
-                  : xs.isNotEmpty() ? splitChildren(acc.cons(xs.head()), xs.tail()._1(), n - 1)
-                                    : Option.none();
-  }
-
-  private static <A> Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> lp3nil() {
-    return nil();
-  }
-
-  /**
-   * Creates a new tree zipper focused on the root of the given tree.
-   *
-   * @param t A tree over which to create a new zipper.
-   * @return a new tree zipper focused on the root of the given tree.
-   */
-  public static <A> TreeZipper<A> fromTree(final Tree<A> t) {
-    return treeZipper(t, Stream.nil(), Stream.nil(), TreeZipper.lp3nil());
-  }
-
-  /**
-   * Creates a new tree zipper focused on the first element of the given forest.
-   *
-   * @param ts A forest over which to create a new zipper.
-   * @return a new tree zipper focused on the first element of the given forest.
-   */
-  public static <A> Option<TreeZipper<A>> fromForest(final Stream<Tree<A>> ts) {
-    return ts.isNotEmpty()
-           ? some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), TreeZipper.lp3nil()))
-           : Option.none();
-  }
-
-  /**
-   * Returns the tree containing this location.
-   *
-   * @return the tree containing this location.
-   */
-  public Tree<A> toTree() {
-    return root().tree;
-  }
-
-  /**
-   * Returns the forest containing this location.
-   *
-   * @return the forest containing this location.
-   */
-  public Stream<Tree<A>> toForest() {
-    final TreeZipper<A> r = root();
-    return combChildren(r.lefts, r.tree, r.rights);
-  }
-
-  /**
-   * Returns the tree at the currently focused node.
-   *
-   * @return the tree at the currently focused node.
-   */
-  public Tree<A> focus() {
-    return tree;
-  }
-
-  /**
-   * Returns the left siblings of the currently focused node.
-   *
-   * @return the left siblings of the currently focused node.
-   */
-  public Stream<Tree<A>> lefts() {
-    return lefts;
-  }
-
-  /**
-   * Returns the right siblings of the currently focused node.
-   *
-   * @return the right siblings of the currently focused node.
-   */
-  public Stream<Tree<A>> rights() {
-        return rights;
-    }
-
-  /**
-   * Returns the parents of the currently focused node.
-   *
-   * @return the parents of the currently focused node.
-   */
-  public Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents() {
-        return parents;
-    }
-
-  /**
-   * Indicates whether the current node is at the top of the tree.
-   *
-   * @return true if the current node is the root of the tree, otherwise false.
-   */
-  public boolean isRoot() {
-    return parents.isEmpty();
-  }
-
-  /**
-   * Indicates whether the current node is the leftmost tree in the current forest.
-   *
-   * @return true if the current node has no left siblings, otherwise false.
-   */
-  public boolean isFirst() {
-    return lefts.isEmpty();
-  }
-
-  /**
-   * Indicates whether the current node is the rightmost tree in the current forest.
-   *
-   * @return true if the current node has no siblings on its right, otherwise false.
-   */
-  public boolean isLast() {
-    return rights.isEmpty();
-  }
-
-  /**
-   * Indicates whether the current node is at the bottom of the tree.
-   *
-   * @return true if the current node has no child nodes, otherwise false.
-   */
-  public boolean isLeaf() {
-    return tree.subForest()._1().isEmpty();
-  }
-
-  /**
-   * Indicates whether the current node is a child node of another node.
-   *
-   * @return true if the current node has a parent node, otherwise false.
-   */
-  public boolean isChild() {
-    return !isRoot();
-  }
-
-  /**
-   * Indicates whether the current node has any child nodes.
-   *
-   * @return true if the current node has child nodes, otherwise false.
-   */
-  public boolean hasChildren() {
-    return !isLeaf();
-  }
-
-  /**
-   * Replaces the current node with the given tree.
-   *
-   * @param t A tree with which to replace the current node.
-   * @return A new tree zipper in which the focused node is replaced with the given tree.
-   */
-  public TreeZipper<A> setTree(final Tree<A> t) {
-    return treeZipper(t, lefts, rights, parents);
-  }
-
-  /**
-   * Modifies the current node with the given function.
-   *
-   * @param f A function with which to modify the current tree.
-   * @return A new tree zipper in which the focused node has been transformed by the given function.
-   */
-  public TreeZipper<A> modifyTree(final F<Tree<A>, Tree<A>> f) {
-    return setTree(f.f(tree));
-  }
-
-  /**
-   * Modifies the label at the current node with the given function.
-   *
-   * @param f A function with which to transform the current node's label.
-   * @return A new tree zipper with the focused node's label transformed by the given function.
-   */
-  public TreeZipper<A> modifyLabel(final F<A, A> f) {
-    return setLabel(f.f(getLabel()));
-  }
-
-  /**
-   * Replaces the label of the current node with the given value.
-   *
-   * @param v The new value for the node's label.
-   * @return A new tree zipper with the focused node's label replaced by the given value.
-   */
-  public TreeZipper<A> setLabel(final A v) {
-    return modifyTree(t -> Tree.node(v, t.subForest()));
-  }
-
-  /**
-   * Returns the label at the current node.
-   *
-   * @return the label at the current node.
-   */
-  public A getLabel() {
-    return tree.root();
-  }
-
-  /**
-   * Inserts a tree to the left of the current position. The inserted tree becomes the current tree.
-   *
-   * @param t A tree to insert to the left of the current position.
-   * @return A new tree zipper with the given tree in focus and the current tree on the right.
-   */
-  public TreeZipper<A> insertLeft(final Tree<A> t) {
-    return treeZipper(t, lefts, rights.cons(tree), parents);
-  }
-
-  /**
-   * Inserts a tree to the right of the current position. The inserted tree becomes the current tree.
-   *
-   * @param t A tree to insert to the right of the current position.
-   * @return A new tree zipper with the given tree in focus and the current tree on the left.
-   */
-  public TreeZipper<A> insertRight(final Tree<A> t) {
-    return treeZipper(t, lefts.cons(tree), rights, parents);
-  }
-
-  /**
-   * Inserts a tree as the first child of the current node. The inserted tree becomes the current tree.
-   *
-   * @param t A tree to insert.
-   * @return A new tree zipper with the given tree in focus, as the first child of the current node.
-   */
-  public TreeZipper<A> insertDownFirst(final Tree<A> t) {
-    return treeZipper(t, Stream.nil(), tree.subForest()._1(), downParents());
-  }
-
-  /**
-   * Inserts a tree as the last child of the current node. The inserted tree becomes the current tree.
-   *
-   * @param t A tree to insert.
-   * @return A new tree zipper with the given tree in focus, as the last child of the current node.
-   */
-  public TreeZipper<A> insertDownLast(final Tree<A> t) {
-    return treeZipper(t, tree.subForest()._1().reverse(), Stream.nil(), downParents());
-  }
-
-  /**
-   * Inserts a tree at the specified location in the current node's stream of children. The inserted tree
-   * becomes the current node.
-   *
-   * @param n The index at which to insert the given tree, starting at 0.
-   * @param t A tree to insert.
-   * @return A new tree zipper with the given tree in focus, at the specified index in the current node's stream
-   *         of children, or None if the current node has fewer than <code>n</code> children.
-   */
-  public Option<TreeZipper<A>> insertDownAt(final int n, final Tree<A> t) {
-    Option<TreeZipper<A>> r = none();
-    for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
-        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
-      r = some(treeZipper(t, lr._1(), lr._2(), downParents()));
-    }
-    return r;
-  }
-
-  /**
-   * Removes the current node from the tree. The new position becomes the right sibling, or the left sibling
-   * if the current node has no right siblings, or the parent node if the current node has no siblings.
-   *
-   * @return A new tree zipper with the current node removed.
-   */
-  public Option<TreeZipper<A>> delete() {
-    Option<TreeZipper<A>> r = none();
-    if (rights.isNotEmpty())
-      r = some(treeZipper(rights.head(), lefts, rights.tail()._1(), parents));
-    else if (lefts.isNotEmpty())
-      r = some(treeZipper(lefts.head(), lefts.tail()._1(), rights, parents));
-    else for (final TreeZipper<A> loc : parent())
-        r = some(loc.modifyTree(t -> node(t.root(), Stream.nil())));
-    return r;
-  }
-
-  /**
-   * Zips the nodes in this zipper with a boolean that indicates whether that node has focus.
-   * All of the booleans will be false, except for the focused node.
-   *
-   * @return A new zipper of pairs, with each node of this zipper paired with a boolean that is true if that
-   *         node has focus, and false otherwise.
-   */
-  public TreeZipper<P2<A, Boolean>> zipWithFocus() {
-    final F<A, P2<A, Boolean>> f = flip(P.<A, Boolean>p2()).f(false);
-    return map(f).modifyLabel(P2.map2_(Booleans.not));
-  }
-
-  /**
-   * Maps the given function across this zipper (covariant functor pattern).
-   *
-   * @param f A function to map across this zipper.
-   * @return A new zipper with the given function applied to the label of every node.
-   */
-  public <B> TreeZipper<B> map(final F<A, B> f) {
-    final F<Tree<A>, Tree<B>> g = Tree.<A, B>fmap_().f(f);
-    final F<Stream<Tree<A>>, Stream<Tree<B>>> h = Stream.<Tree<A>, Tree<B>>map_().f(g);
-    return treeZipper(tree.fmap(f), lefts.map(g), rights.map(g), parents.map(
-            p -> p.map1(h).map2(f).map3(h)));
-  }
-
-  /**
-   * First-class conversion of a Tree to the corresponding tree zipper.
-   *
-   * @return A function that takes a tree to its tree zipper representation.
-   */
-  public static <A> F<Tree<A>, TreeZipper<A>> fromTree() {
-    return TreeZipper::fromTree;
-  }
-
-  /**
-   * A first-class version of the left() function.
-   *
-   * @return A function that focuses the given tree zipper on its left sibling.
-   */
-  public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> left_() {
-    return TreeZipper::left;
-  }
-
-  /**
-   * A first-class version of the right() function.
-   *
-   * @return A function that focuses the given tree zipper on its right sibling.
-   */
-  public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> right_() {
-    return TreeZipper::right;
-  }
-
-  /**
-   * Returns a zipper over the tree of all possible permutations of this tree zipper (comonad pattern).
-   * This tree zipper becomes the focused node of the new zipper.
-   *
-   * @return A tree zipper over the tree of all possible permutations of this tree zipper.
-   */
-  public TreeZipper<TreeZipper<A>> positions() {
-    final Tree<TreeZipper<A>> t = unfoldTree(TreeZipper.<A>dwn()).f(this);
-    final Stream<Tree<TreeZipper<A>>> l = uf(TreeZipper.left_());
-    final Stream<Tree<TreeZipper<A>>> r = uf(TreeZipper.right_());
-    final Stream<P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>> p = unfold(
-        o -> {
-          Option<P2<
-              P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
-              Option<TreeZipper<A>>>> r1 = none();
-          for (final TreeZipper<A> z : o) {
-            r1 = some(P.p(P.p(z.uf(TreeZipper.left_()), z, z.uf(TreeZipper.right_())), z.parent()));
-          }
-          return r1;
-        }, parent());
-    return treeZipper(t, l, r, p);
-  }
-
-  private Stream<Tree<TreeZipper<A>>> uf(final F<TreeZipper<A>, Option<TreeZipper<A>>> f) {
-    return unfold(
-            o -> {
-              Option<P2<Tree<TreeZipper<A>>, Option<TreeZipper<A>>>> r = none();
-              for (final TreeZipper<A> c : o) {
-                r = some(P.p(unfoldTree(TreeZipper.<A>dwn()).f(c), f.f(c)));
-              }
-              return r;
-            }, f.f(this));
-  }
-
-  private static <A> F<TreeZipper<A>, P2<TreeZipper<A>, P1<Stream<TreeZipper<A>>>>> dwn() {
-    F<Option<TreeZipper<A>>, Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>>> fwd = o -> o.map(c -> P.p(c, c.right()));
-    return tz -> P.p(tz, P.lazy(() -> unfold(fwd, tz.firstChild())));
-  }
-
-  /**
-   * Maps the given function over the tree of all positions for this zipper (comonad pattern). Returns a zipper
-   * over the tree of results of the function application.
-   *
-   * @param f A function to map over the tree of all positions for this zipper.
-   * @return A zipper over the tree of results of the function application.
-   */
-  public <B> TreeZipper<B> cobind(final F<TreeZipper<A>, B> f) {
-    return positions().map(f);
-  }
-
-  /**
-   * A first-class version of the findChild function.
-   *
-   * @return a function that finds the first child, of a given tree zipper, that matches a given predicate.
-   */
-  public static <A> F2<F<Tree<A>, Boolean>, TreeZipper<A>, Option<TreeZipper<A>>> findChild() {
-    return (f, az) -> az.findChild(f);
-  }
-
-  /**
-   * Zips this TreeZipper with another, applying the given function lock-step over both zippers in all directions.
-   * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
-   *
-   * @param bs A TreeZipper to zip this one with.
-   * @param f  A function with which to zip together the two TreeZippers.
-   * @return The result of applying the given function over this TreeZipper and the given TreeZipper, location-wise.
-   */
-  public <B, C> TreeZipper<C> zipWith(final TreeZipper<B> bs, final F2<A, B, C> f) {
-    return F2Functions.zipTreeZipperM(f).f(this, bs);
-  }
-
-  /**
-   * Zips this TreeZipper with another, applying the given function lock-step over both zippers in all directions.
-   * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
-   *
-   * @param bs A TreeZipper to zip this one with.
-   * @param f  A function with which to zip together the two TreeZippers.
-   * @return The result of applying the given function over this TreeZipper and the given TreeZipper, location-wise.
-   */
-  public <B, C> TreeZipper<C> zipWith(final TreeZipper<B> bs, final F<A, F<B, C>> f) {
-    return zipWith(bs, uncurryF2(f));
-  }
-}
+package fj.data;
+
+import fj.*;
+import fj.function.Booleans;
+
+import java.util.Iterator;
+
+import static fj.Equal.p3Equal;
+import static fj.Equal.p4Equal;
+import static fj.Equal.streamEqual;
+import static fj.Equal.treeEqual;
+import static fj.Function.compose;
+import static fj.Function.curry;
+import static fj.Function.flip;
+import static fj.Function.uncurryF2;
+import static fj.Show.p3Show;
+import static fj.Show.p4Show;
+import static fj.Show.streamShow;
+import static fj.Show.treeShow;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+import static fj.data.Stream.nil;
+import static fj.data.Stream.unfold;
+import static fj.data.Tree.node;
+import static fj.data.Tree.unfoldTree;
+
+/**
+ * Provides a zipper structure for rose trees, which is a Tree supplied with a location within that tree.
+ * Provides navigation, insertion, deletion, and memorization of visited locations within a tree.
+ */
+public final class TreeZipper<A> implements Iterable<TreeZipper<A>> {
+
+  /**
+   * Returns an iterator of all the positions of this TreeZipper. Exists for use with the foreach syntax.
+   *
+   * @return An iterator of all the positions of this TreeZipper.
+   */
+  public Iterator<TreeZipper<A>> iterator() {
+    return positions().toTree().iterator();
+  }
+
+  private final Tree<A> tree;
+  private final Stream<Tree<A>> lefts;
+  private final Stream<Tree<A>> rights;
+  private final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents;
+
+  private TreeZipper(final Tree<A> tree,
+                     final Stream<Tree<A>> lefts,
+                     final Stream<Tree<A>> rights,
+                     final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents) {
+    this.tree = tree;
+    this.lefts = lefts;
+    this.rights = rights;
+    this.parents = parents;
+  }
+
+    @Override
+    public final boolean equals(Object other) {
+        return Equal.equals0(TreeZipper.class, this, other, () -> Equal.treeZipperEqual(Equal.anyEqual()));
+    }
+
+    @Override
+    public final int hashCode() {
+        return Hash.treeZipperHash(Hash.<A>anyHash()).hash(this);
+    }
+
+    /**
+   * Creates a new tree zipper given a currently selected tree, a forest on the left, a forest on the right,
+   * and a stream of parent contexts.
+   *
+   * @param tree    The currently selected tree.
+   * @param lefts   The selected tree's left siblings, closest first.
+   * @param rights  The selected tree's right siblings, closest first.
+   * @param parents The parent of the selected tree, and the parent's siblings.
+   * @return A new zipper with the given tree selected, and the given forests on the left and right.
+   */
+  public static <A> TreeZipper<A> treeZipper(final Tree<A> tree,
+                                             final Stream<Tree<A>> lefts,
+                                             final Stream<Tree<A>> rights,
+                                             final Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents) {
+    return new TreeZipper<>(tree, lefts, rights, parents);
+  }
+
+  /**
+   * First-class constructor for tree zippers.
+   *
+   * @return A function that returns a new tree zipper, given a selected tree, left and right siblings,
+   *         and a parent context.
+   */
+  public static <A>
+  F<Tree<A>, F<Stream<Tree<A>>, F<Stream<Tree<A>>, F<Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>, TreeZipper<A>>>>>
+  treeZipper() {
+    return curry(
+        TreeZipper::treeZipper);
+  }
+
+  /**
+   * Returns the product-4 representation of this zipper.
+   *
+   * @return the product-4 representation of this zipper.
+   */
+  public P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>> p() {
+    return P.p(tree, lefts, rights, parents);
+  }
+
+  /**
+   * A first-class function that returns the product-4 representation of a given zipper.
+   *
+   * @return a function that converts a given zipper to its product-4 representation.
+   */
+  public static <A>
+  F<TreeZipper<A>, P4<Tree<A>, Stream<Tree<A>>, Stream<Tree<A>>, Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>>>> p_() {
+    return TreeZipper::p;
+  }
+
+  /**
+   * An Equal instance for tree zippers.
+   *
+   * @param e An Equal instance for tree elements.
+   * @return An Equal instance for tree zippers.
+   */
+  public static <A> Equal<TreeZipper<A>> eq(final Equal<A> e) {
+    return p4Equal(
+        treeEqual(e),
+        streamEqual(treeEqual(e)),
+        streamEqual(treeEqual(e)),
+        streamEqual(p3Equal(streamEqual(treeEqual(e)), e, streamEqual(treeEqual(e))))).contramap(TreeZipper.p_());
+  }
+
+  /**
+   * A Show instance for tree zippers.
+   *
+   * @param s A Show instance for tree elements.
+   * @return A Show instance for tree zippers.
+   */
+  public static <A> Show<TreeZipper<A>> show(final Show<A> s) {
+    return p4Show(
+        treeShow(s),
+        streamShow(treeShow(s)),
+        streamShow(treeShow(s)),
+        streamShow(p3Show(streamShow(treeShow(s)), s, streamShow(treeShow(s))))).contramap(TreeZipper.p_());
+  }
+
+  private static <A> Stream<Tree<A>> combChildren(final Stream<Tree<A>> ls,
+                                                  final Tree<A> t,
+                                                  final Stream<Tree<A>> rs) {
+    return ls.foldLeft(compose(flip(Stream.cons()), P.p1()), Stream.cons(t, P.p(rs)));
+  }
+
+  /**
+   * Navigates to the parent of the current location.
+   *
+   * @return A new tree zipper focused on the parent node of the current node,
+   *         or none if the current node is the root node.
+   */
+  public Option<TreeZipper<A>> parent() {
+    if (parents.isEmpty())
+      return none();
+    else {
+      final P3<Stream<Tree<A>>, A, Stream<Tree<A>>> p = parents.head();
+      return some(treeZipper(node(p._2(), combChildren(lefts, tree, rights)), p._1(), p._3(), parents.tail()._1()));
+    }
+  }
+
+  /**
+   * Navigates to the top-most parent of the current location.
+   *
+   * @return A new tree zipper focused on the top-most parent of the current node.
+   */
+  public TreeZipper<A> root() {
+    return parent().option(this, TreeZipper.root_());
+  }
+
+  /**
+   * A first-class version of the root function.
+   *
+   * @return A function that returns a new tree-zipper focused on the root of the given tree zipper's tree.
+   */
+  public static <A> F<TreeZipper<A>, TreeZipper<A>> root_() {
+    return TreeZipper::root;
+  }
+
+  /**
+   * Navigates to the left sibling of the current location.
+   *
+   * @return A new tree zipper focused on the left sibling of the current node,
+   *         or none if there are no siblings on the left.
+   */
+  public Option<TreeZipper<A>> left() {
+    return lefts.isEmpty() ? Option.none()
+                           : some(treeZipper(lefts.head(), lefts.tail()._1(), rights.cons(tree), parents));
+  }
+
+  /**
+   * Navigates to the right sibling of the current location.
+   *
+   * @return A new tree zipper focused on the right sibling of the current node,
+   *         or none if there are no siblings on the right.
+   */
+  public Option<TreeZipper<A>> right() {
+    return rights.isEmpty() ? Option.none()
+                            : some(treeZipper(rights.head(), lefts.cons(tree), rights.tail()._1(), parents));
+  }
+
+  /**
+   * Navigtes to the first child of the current location.
+   *
+   * @return A new tree zipper focused on the first child of the current node, or none if the node has no children.
+   */
+  public Option<TreeZipper<A>> firstChild() {
+    final Stream<Tree<A>> ts = tree.subForest()._1();
+    return ts.isEmpty() ? Option.none()
+                        : some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), downParents()));
+  }
+
+  /**
+   * Navigtes to the last child of the current location.
+   *
+   * @return A new tree zipper focused on the last child of the current node, or none if the node has no children.
+   */
+  public Option<TreeZipper<A>> lastChild() {
+    final Stream<Tree<A>> ts = tree.subForest()._1().reverse();
+    return ts.isEmpty() ? Option.none()
+                        : some(treeZipper(ts.head(), ts.tail()._1(), Stream.nil(), downParents()));
+  }
+
+  /**
+   * Navigates to the given child of the current location, starting at index 0.
+   *
+   * @param n The index of the child to which to navigate.
+   * @return An optional tree zipper focused on the child node at the given index, or none if there is no such child.
+   */
+  public Option<TreeZipper<A>> getChild(final int n) {
+    Option<TreeZipper<A>> r = none();
+    for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
+        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
+      r = some(treeZipper(lr._1().head(), lr._1().tail()._1(), lr._2(), downParents()));
+    }
+    return r;
+  }
+
+  /**
+   * Navigates to the first child of the current location, that satisfies the given predicate.
+   *
+   * @param p A predicate to be satisfied by the child node.
+   * @return An optional tree zipper focused on the first child node that satisfies the given predicate,
+   *         or none if there is no such child.
+   */
+  public Option<TreeZipper<A>> findChild(final F<Tree<A>, Boolean> p) {
+    Option<TreeZipper<A>> r = none();
+
+    final F2<Stream<Tree<A>>, Stream<Tree<A>>, Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>>> split =
+        new F2<Stream<Tree<A>>, Stream<Tree<A>>, Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>>>() {
+          public Option<P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>>> f(final Stream<Tree<A>> acc,
+                                                                         final Stream<Tree<A>> xs) {
+            return xs.isNotEmpty()
+                     ? p.f(xs.head()) ? some(P.p(acc, xs.head(), xs.tail()._1()))
+                                      : f(acc.cons(xs.head()), xs.tail()._1())
+                     : Option.none();
+          }
+        };
+
+    Stream<Tree<A>> subforest = tree.subForest()._1();
+    if (subforest.isNotEmpty()) {
+      for (final P3<Stream<Tree<A>>, Tree<A>, Stream<Tree<A>>> ltr
+        : split.f(Stream.nil(), subforest)) {
+        r = some(treeZipper(ltr._2(), ltr._1(), ltr._3(), downParents()));
+      }
+    }
+    return r;
+  }
+
+  private Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> downParents() {
+    return parents.cons(P.p(lefts, tree.root(), rights));
+  }
+
+  private static <A> Option<P2<Stream<A>, Stream<A>>> splitChildren(final Stream<A> acc,
+                                                                    final Stream<A> xs,
+                                                                    final int n) {
+    return n == 0 ? some(P.p(acc, xs))
+                  : xs.isNotEmpty() ? splitChildren(acc.cons(xs.head()), xs.tail()._1(), n - 1)
+                                    : Option.none();
+  }
+
+  private static <A> Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> lp3nil() {
+    return nil();
+  }
+
+  /**
+   * Creates a new tree zipper focused on the root of the given tree.
+   *
+   * @param t A tree over which to create a new zipper.
+   * @return a new tree zipper focused on the root of the given tree.
+   */
+  public static <A> TreeZipper<A> fromTree(final Tree<A> t) {
+    return treeZipper(t, Stream.nil(), Stream.nil(), TreeZipper.lp3nil());
+  }
+
+  /**
+   * Creates a new tree zipper focused on the first element of the given forest.
+   *
+   * @param ts A forest over which to create a new zipper.
+   * @return a new tree zipper focused on the first element of the given forest.
+   */
+  public static <A> Option<TreeZipper<A>> fromForest(final Stream<Tree<A>> ts) {
+    return ts.isNotEmpty()
+           ? some(treeZipper(ts.head(), Stream.nil(), ts.tail()._1(), TreeZipper.lp3nil()))
+           : Option.none();
+  }
+
+  /**
+   * Returns the tree containing this location.
+   *
+   * @return the tree containing this location.
+   */
+  public Tree<A> toTree() {
+    return root().tree;
+  }
+
+  /**
+   * Returns the forest containing this location.
+   *
+   * @return the forest containing this location.
+   */
+  public Stream<Tree<A>> toForest() {
+    final TreeZipper<A> r = root();
+    return combChildren(r.lefts, r.tree, r.rights);
+  }
+
+  /**
+   * Returns the tree at the currently focused node.
+   *
+   * @return the tree at the currently focused node.
+   */
+  public Tree<A> focus() {
+    return tree;
+  }
+
+  /**
+   * Returns the left siblings of the currently focused node.
+   *
+   * @return the left siblings of the currently focused node.
+   */
+  public Stream<Tree<A>> lefts() {
+    return lefts;
+  }
+
+  /**
+   * Returns the right siblings of the currently focused node.
+   *
+   * @return the right siblings of the currently focused node.
+   */
+  public Stream<Tree<A>> rights() {
+        return rights;
+    }
+
+  /**
+   * Returns the parents of the currently focused node.
+   *
+   * @return the parents of the currently focused node.
+   */
+  public Stream<P3<Stream<Tree<A>>, A, Stream<Tree<A>>>> parents() {
+        return parents;
+    }
+
+  /**
+   * Indicates whether the current node is at the top of the tree.
+   *
+   * @return true if the current node is the root of the tree, otherwise false.
+   */
+  public boolean isRoot() {
+    return parents.isEmpty();
+  }
+
+  /**
+   * Indicates whether the current node is the leftmost tree in the current forest.
+   *
+   * @return true if the current node has no left siblings, otherwise false.
+   */
+  public boolean isFirst() {
+    return lefts.isEmpty();
+  }
+
+  /**
+   * Indicates whether the current node is the rightmost tree in the current forest.
+   *
+   * @return true if the current node has no siblings on its right, otherwise false.
+   */
+  public boolean isLast() {
+    return rights.isEmpty();
+  }
+
+  /**
+   * Indicates whether the current node is at the bottom of the tree.
+   *
+   * @return true if the current node has no child nodes, otherwise false.
+   */
+  public boolean isLeaf() {
+    return tree.subForest()._1().isEmpty();
+  }
+
+  /**
+   * Indicates whether the current node is a child node of another node.
+   *
+   * @return true if the current node has a parent node, otherwise false.
+   */
+  public boolean isChild() {
+    return !isRoot();
+  }
+
+  /**
+   * Indicates whether the current node has any child nodes.
+   *
+   * @return true if the current node has child nodes, otherwise false.
+   */
+  public boolean hasChildren() {
+    return !isLeaf();
+  }
+
+  /**
+   * Replaces the current node with the given tree.
+   *
+   * @param t A tree with which to replace the current node.
+   * @return A new tree zipper in which the focused node is replaced with the given tree.
+   */
+  public TreeZipper<A> setTree(final Tree<A> t) {
+    return treeZipper(t, lefts, rights, parents);
+  }
+
+  /**
+   * Modifies the current node with the given function.
+   *
+   * @param f A function with which to modify the current tree.
+   * @return A new tree zipper in which the focused node has been transformed by the given function.
+   */
+  public TreeZipper<A> modifyTree(final F<Tree<A>, Tree<A>> f) {
+    return setTree(f.f(tree));
+  }
+
+  /**
+   * Modifies the label at the current node with the given function.
+   *
+   * @param f A function with which to transform the current node's label.
+   * @return A new tree zipper with the focused node's label transformed by the given function.
+   */
+  public TreeZipper<A> modifyLabel(final F<A, A> f) {
+    return setLabel(f.f(getLabel()));
+  }
+
+  /**
+   * Replaces the label of the current node with the given value.
+   *
+   * @param v The new value for the node's label.
+   * @return A new tree zipper with the focused node's label replaced by the given value.
+   */
+  public TreeZipper<A> setLabel(final A v) {
+    return modifyTree(t -> Tree.node(v, t.subForest()));
+  }
+
+  /**
+   * Returns the label at the current node.
+   *
+   * @return the label at the current node.
+   */
+  public A getLabel() {
+    return tree.root();
+  }
+
+  /**
+   * Inserts a tree to the left of the current position. The inserted tree becomes the current tree.
+   *
+   * @param t A tree to insert to the left of the current position.
+   * @return A new tree zipper with the given tree in focus and the current tree on the right.
+   */
+  public TreeZipper<A> insertLeft(final Tree<A> t) {
+    return treeZipper(t, lefts, rights.cons(tree), parents);
+  }
+
+  /**
+   * Inserts a tree to the right of the current position. The inserted tree becomes the current tree.
+   *
+   * @param t A tree to insert to the right of the current position.
+   * @return A new tree zipper with the given tree in focus and the current tree on the left.
+   */
+  public TreeZipper<A> insertRight(final Tree<A> t) {
+    return treeZipper(t, lefts.cons(tree), rights, parents);
+  }
+
+  /**
+   * Inserts a tree as the first child of the current node. The inserted tree becomes the current tree.
+   *
+   * @param t A tree to insert.
+   * @return A new tree zipper with the given tree in focus, as the first child of the current node.
+   */
+  public TreeZipper<A> insertDownFirst(final Tree<A> t) {
+    return treeZipper(t, Stream.nil(), tree.subForest()._1(), downParents());
+  }
+
+  /**
+   * Inserts a tree as the last child of the current node. The inserted tree becomes the current tree.
+   *
+   * @param t A tree to insert.
+   * @return A new tree zipper with the given tree in focus, as the last child of the current node.
+   */
+  public TreeZipper<A> insertDownLast(final Tree<A> t) {
+    return treeZipper(t, tree.subForest()._1().reverse(), Stream.nil(), downParents());
+  }
+
+  /**
+   * Inserts a tree at the specified location in the current node's stream of children. The inserted tree
+   * becomes the current node.
+   *
+   * @param n The index at which to insert the given tree, starting at 0.
+   * @param t A tree to insert.
+   * @return A new tree zipper with the given tree in focus, at the specified index in the current node's stream
+   *         of children, or None if the current node has fewer than <code>n</code> children.
+   */
+  public Option<TreeZipper<A>> insertDownAt(final int n, final Tree<A> t) {
+    Option<TreeZipper<A>> r = none();
+    for (final P2<Stream<Tree<A>>, Stream<Tree<A>>> lr
+        : splitChildren(Stream.nil(), tree.subForest()._1(), n)) {
+      r = some(treeZipper(t, lr._1(), lr._2(), downParents()));
+    }
+    return r;
+  }
+
+  /**
+   * Removes the current node from the tree. The new position becomes the right sibling, or the left sibling
+   * if the current node has no right siblings, or the parent node if the current node has no siblings.
+   *
+   * @return A new tree zipper with the current node removed.
+   */
+  public Option<TreeZipper<A>> delete() {
+    Option<TreeZipper<A>> r = none();
+    if (rights.isNotEmpty())
+      r = some(treeZipper(rights.head(), lefts, rights.tail()._1(), parents));
+    else if (lefts.isNotEmpty())
+      r = some(treeZipper(lefts.head(), lefts.tail()._1(), rights, parents));
+    else for (final TreeZipper<A> loc : parent())
+        r = some(loc.modifyTree(t -> node(t.root(), Stream.nil())));
+    return r;
+  }
+
+  /**
+   * Zips the nodes in this zipper with a boolean that indicates whether that node has focus.
+   * All of the booleans will be false, except for the focused node.
+   *
+   * @return A new zipper of pairs, with each node of this zipper paired with a boolean that is true if that
+   *         node has focus, and false otherwise.
+   */
+  public TreeZipper<P2<A, Boolean>> zipWithFocus() {
+    final F<A, P2<A, Boolean>> f = flip(P.<A, Boolean>p2()).f(false);
+    return map(f).modifyLabel(P2.map2_(Booleans.not));
+  }
+
+  /**
+   * Maps the given function across this zipper (covariant functor pattern).
+   *
+   * @param f A function to map across this zipper.
+   * @return A new zipper with the given function applied to the label of every node.
+   */
+  public <B> TreeZipper<B> map(final F<A, B> f) {
+    final F<Tree<A>, Tree<B>> g = Tree.<A, B>fmap_().f(f);
+    final F<Stream<Tree<A>>, Stream<Tree<B>>> h = Stream.<Tree<A>, Tree<B>>map_().f(g);
+    return treeZipper(tree.fmap(f), lefts.map(g), rights.map(g), parents.map(
+            p -> p.map1(h).map2(f).map3(h)));
+  }
+
+  /**
+   * First-class conversion of a Tree to the corresponding tree zipper.
+   *
+   * @return A function that takes a tree to its tree zipper representation.
+   */
+  public static <A> F<Tree<A>, TreeZipper<A>> fromTree() {
+    return TreeZipper::fromTree;
+  }
+
+  /**
+   * A first-class version of the left() function.
+   *
+   * @return A function that focuses the given tree zipper on its left sibling.
+   */
+  public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> left_() {
+    return TreeZipper::left;
+  }
+
+  /**
+   * A first-class version of the right() function.
+   *
+   * @return A function that focuses the given tree zipper on its right sibling.
+   */
+  public static <A> F<TreeZipper<A>, Option<TreeZipper<A>>> right_() {
+    return TreeZipper::right;
+  }
+
+  /**
+   * Returns a zipper over the tree of all possible permutations of this tree zipper (comonad pattern).
+   * This tree zipper becomes the focused node of the new zipper.
+   *
+   * @return A tree zipper over the tree of all possible permutations of this tree zipper.
+   */
+  public TreeZipper<TreeZipper<A>> positions() {
+    final Tree<TreeZipper<A>> t = unfoldTree(TreeZipper.<A>dwn()).f(this);
+    final Stream<Tree<TreeZipper<A>>> l = uf(TreeZipper.left_());
+    final Stream<Tree<TreeZipper<A>>> r = uf(TreeZipper.right_());
+    final Stream<P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>> p = unfold(
+        o -> {
+          Option<P2<
+              P3<Stream<Tree<TreeZipper<A>>>, TreeZipper<A>, Stream<Tree<TreeZipper<A>>>>,
+              Option<TreeZipper<A>>>> r1 = none();
+          for (final TreeZipper<A> z : o) {
+            r1 = some(P.p(P.p(z.uf(TreeZipper.left_()), z, z.uf(TreeZipper.right_())), z.parent()));
+          }
+          return r1;
+        }, parent());
+    return treeZipper(t, l, r, p);
+  }
+
+  private Stream<Tree<TreeZipper<A>>> uf(final F<TreeZipper<A>, Option<TreeZipper<A>>> f) {
+    return unfold(
+            o -> {
+              Option<P2<Tree<TreeZipper<A>>, Option<TreeZipper<A>>>> r = none();
+              for (final TreeZipper<A> c : o) {
+                r = some(P.p(unfoldTree(TreeZipper.<A>dwn()).f(c), f.f(c)));
+              }
+              return r;
+            }, f.f(this));
+  }
+
+  private static <A> F<TreeZipper<A>, P2<TreeZipper<A>, P1<Stream<TreeZipper<A>>>>> dwn() {
+    F<Option<TreeZipper<A>>, Option<P2<TreeZipper<A>, Option<TreeZipper<A>>>>> fwd = o -> o.map(c -> P.p(c, c.right()));
+    return tz -> P.p(tz, P.lazy(() -> unfold(fwd, tz.firstChild())));
+  }
+
+  /**
+   * Maps the given function over the tree of all positions for this zipper (comonad pattern). Returns a zipper
+   * over the tree of results of the function application.
+   *
+   * @param f A function to map over the tree of all positions for this zipper.
+   * @return A zipper over the tree of results of the function application.
+   */
+  public <B> TreeZipper<B> cobind(final F<TreeZipper<A>, B> f) {
+    return positions().map(f);
+  }
+
+  /**
+   * A first-class version of the findChild function.
+   *
+   * @return a function that finds the first child, of a given tree zipper, that matches a given predicate.
+   */
+  public static <A> F2<F<Tree<A>, Boolean>, TreeZipper<A>, Option<TreeZipper<A>>> findChild() {
+    return (f, az) -> az.findChild(f);
+  }
+
+  /**
+   * Zips this TreeZipper with another, applying the given function lock-step over both zippers in all directions.
+   * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
+   *
+   * @param bs A TreeZipper to zip this one with.
+   * @param f  A function with which to zip together the two TreeZippers.
+   * @return The result of applying the given function over this TreeZipper and the given TreeZipper, location-wise.
+   */
+  public <B, C> TreeZipper<C> zipWith(final TreeZipper<B> bs, final F2<A, B, C> f) {
+    return f.zipTreeZipperM().f(this, bs);
+  }
+
+  /**
+   * Zips this TreeZipper with another, applying the given function lock-step over both zippers in all directions.
+   * The structure of the resulting TreeZipper is the structural intersection of the two TreeZippers.
+   *
+   * @param bs A TreeZipper to zip this one with.
+   * @param f  A function with which to zip together the two TreeZippers.
+   * @return The result of applying the given function over this TreeZipper and the given TreeZipper, location-wise.
+   */
+  public <B, C> TreeZipper<C> zipWith(final TreeZipper<B> bs, final F<A, F<B, C>> f) {
+    return zipWith(bs, uncurryF2(f));
+  }
+}
diff --git a/core/src/main/java/fj/data/Zipper.java b/core/src/main/java/fj/data/Zipper.java
index 2514d8e2..4b96377f 100644
--- a/core/src/main/java/fj/data/Zipper.java
+++ b/core/src/main/java/fj/data/Zipper.java
@@ -1,585 +1,585 @@
-package fj.data;
-
-import fj.*;
-import fj.function.Integers;
-
-import java.util.Iterator;
-
-import static fj.Function.compose;
-import static fj.Function.curry;
-import static fj.Function.flip;
-import static fj.Function.join;
-import static fj.Function.uncurryF2;
-import static fj.data.Option.none;
-import static fj.data.Option.some;
-import static fj.data.Stream.nil;
-import static fj.data.Stream.repeat;
-
-/**
- * Provides a pointed stream, which is a non-empty zipper-like stream structure that tracks an index (focus)
- * position in a stream. Focus can be moved forward and backwards through the stream, elements can be inserted
- * before or after the focused position, and the focused item can be deleted.
- * <p/>
- * Based on the pointedlist library by Jeff Wheeler.
- */
-public final class Zipper<A> implements Iterable<Zipper<A>> {
-  private final Stream<A> left;
-  private final A focus;
-  private final Stream<A> right;
-
-  private Zipper(final Stream<A> left, final A focus, final Stream<A> right) {
-    this.left = left;
-    this.focus = focus;
-    this.right = right;
-  }
-
-
-  /**
-   * Creates a new Zipper with the given streams before and after the focus, and the given focused item.
-   *
-   * @param left  The stream of elements before the focus.
-   * @param focus The element under focus.
-   * @param right The stream of elements after the focus.
-   * @return a new Zipper with the given streams before and after the focus, and the given focused item.
-   */
-  public static <A> Zipper<A> zipper(final Stream<A> left, final A focus, final Stream<A> right) {
-    return new Zipper<>(left, focus, right);
-  }
-
-  /**
-   * Creates a new Zipper from the given triple.
-   *
-   * @param p A triple of the elements before the focus, the focus element, and the elements after the focus,
-   *          respectively.
-   * @return a new Zipper created from the given triple.
-   */
-  public static <A> Zipper<A> zipper(final P3<Stream<A>, A, Stream<A>> p) {
-    return new Zipper<>(p._1(), p._2(), p._3());
-  }
-
-  /**
-   * First-class constructor of zippers.
-   *
-   * @return A function that yields a new zipper given streams on the left and right and a focus element.
-   */
-  public static <A> F3<Stream<A>, A, Stream<A>, Zipper<A>> zipper() {
-    return Zipper::zipper;
-  }
-
-  /**
-   * Returns the product-3 representation of this Zipper.
-   *
-   * @return the product-3 representation of this Zipper.
-   */
-  public P3<Stream<A>, A, Stream<A>> p() {
-    return P.p(left, focus, right);
-  }
-
-  /**
-   * A first-class function that yields the product-3 representation of a given Zipper.
-   *
-   * @return A first-class function that yields the product-3 representation of a given Zipper.
-   */
-  public static <A> F<Zipper<A>, P3<Stream<A>, A, Stream<A>>> p_() {
-    return Zipper::p;
-  }
-
-  /**
-   * An Ord instance for Zippers.
-   *
-   * @param o An Ord instance for the element type.
-   * @return An Ord instance for Zippers.
-   */
-  public static <A> Ord<Zipper<A>> ord(final Ord<A> o) {
-    final Ord<Stream<A>> so = Ord.streamOrd(o);
-    return Ord.p3Ord(so, o, so).contramap(Zipper.p_());
-  }
-
-  @Override
-  public final boolean equals(Object other) {
-    return Equal.equals0(Zipper.class, this, other, () -> Equal.zipperEqual(Equal.anyEqual()));
-  }
-
-  @Override
-  public final int hashCode() {
-    return Hash.zipperHash(Hash.<A>anyHash()).hash(this);
-  }
-
-  /**
-   * An Equal instance for Zippers.
-   *
-   * @param e An Equal instance for the element type.
-   * @return An Equal instance for Zippers.
-   */
-  public static <A> Equal<Zipper<A>> eq(final Equal<A> e) {
-    final Equal<Stream<A>> se = Equal.streamEqual(e);
-    return Equal.p3Equal(se, e, se).contramap(Zipper.p_());
-  }
-
-  /**
-   * A Show instance for Zippers.
-   *
-   * @param s A Show instance for the element type.
-   * @return A Show instance for Zippers.
-   */
-  public static <A> Show<Zipper<A>> show(final Show<A> s) {
-    final Show<Stream<A>> ss = Show.streamShow(s);
-    return Show.p3Show(ss, s, ss).contramap(Zipper.p_());
-  }
-
-  /**
-   * Maps the given function across the elements of this zipper (covariant functor pattern).
-   *
-   * @param f A function to map across this zipper.
-   * @return A new zipper with the given function applied to all elements.
-   */
-  public <B> Zipper<B> map(final F<A, B> f) {
-    return zipper(left.map(f), f.f(focus), right.map(f));
-  }
-
-  /**
-   * Performs a right-fold reduction across this zipper.
-   *
-   * @param f The function to apply on each element of this zipper.
-   * @param z The beginning value to start the application from.
-   * @return the final result after the right-fold reduction.
-   */
-  public <B> B foldRight(final F<A, F<B, B>> f, final B z) {
-    return left.foldLeft(flip(f),
-                         right.cons(focus).foldRight(compose(
-                             Function.<P1<B>, B, B>andThen().f(P1.__1()), f), z));
-  }
-
-  /**
-   * Creates a new zipper with a single element.
-   *
-   * @param a The focus element of the new zipper.
-   * @return a new zipper with a single element which is in focus.
-   */
-  public static <A> Zipper<A> single(final A a) {
-    return zipper(Stream.nil(), a, Stream.nil());
-  }
-
-  /**
-   * Possibly create a zipper if the provided stream has at least one element, otherwise None.
-   * The provided stream's head will be the focus of the zipper, and the rest of the stream will follow
-   * on the right side.
-   *
-   * @param a The stream from which to create a zipper.
-   * @return a new zipper if the provided stream has at least one element, otherwise None.
-   */
-  @SuppressWarnings("IfMayBeConditional")
-  public static <A> Option<Zipper<A>> fromStream(final Stream<A> a) {
-    if (a.isEmpty())
-      return none();
-    else
-      return some(zipper(Stream.nil(), a.head(), a.tail()._1()));
-  }
-
-  /**
-   * Possibly create a zipper if the provided stream has at least one element, otherwise None.
-   * The provided stream's last element will be the focus of the zipper, following the rest of the stream in order,
-   * to the left.
-   *
-   * @param a The stream from which to create a zipper.
-   * @return a new zipper if the provided stream has at least one element, otherwise None.
-   */
-  public static <A> Option<Zipper<A>> fromStreamEnd(final Stream<A> a) {
-    if (a.isEmpty())
-      return none();
-    else {
-      final Stream<A> xs = a.reverse();
-      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
-    }
-  }
-
-  /**
-   * Returns the focus element of this zipper.
-   *
-   * @return the focus element of this zipper.
-   */
-  public A focus() {
-    return focus;
-  }
-
-  /**
-   * Possibly moves the focus to the next element in the list.
-   *
-   * @return An optional zipper with the focus moved one element to the right, if there are elements to the right of
-   *         focus, otherwise None.
-   */
-  public Option<Zipper<A>> next() {
-    return right.isEmpty() ? Option.none() : some(tryNext());
-  }
-
-  /**
-   * Attempts to move the focus to the next element, or throws an error if there are no more elements.
-   *
-   * @return A zipper with the focus moved one element to the right, if there are elements to the right of
-   *         focus, otherwise throws an error.
-   */
-  public Zipper<A> tryNext() {
-    if (right.isEmpty())
-      throw new Error("Tried next at the end of a zipper.");
-    else
-      return zipper(left.cons(focus), right.head(), right.tail()._1());
-  }
-
-  /**
-   * Possibly moves the focus to the previous element in the list.
-   *
-   * @return An optional zipper with the focus moved one element to the left, if there are elements to the left of
-   *         focus, otherwise None.
-   */
-  public Option<Zipper<A>> previous() {
-    return left.isEmpty() ? Option.none() : some(tryPrevious());
-  }
-
-  /**
-   * Attempts to move the focus to the previous element, or throws an error if there are no more elements.
-   *
-   * @return A zipper with the focus moved one element to the left, if there are elements to the left of
-   *         focus, otherwise throws an error.
-   */
-  public Zipper<A> tryPrevious() {
-    if (left.isEmpty())
-      throw new Error("Tried previous at the beginning of a zipper.");
-    else
-      return zipper(left.tail()._1(), left.head(), right.cons(focus));
-  }
-
-  /**
-   * First-class version of the next() function.
-   *
-   * @return A function that moves the given zipper's focus to the next element.
-   */
-  public static <A> F<Zipper<A>, Option<Zipper<A>>> next_() {
-    return Zipper::next;
-  }
-
-  /**
-   * First-class version of the previous() function.
-   *
-   * @return A function that moves the given zipper's focus to the previous element.
-   */
-  public static <A> F<Zipper<A>, Option<Zipper<A>>> previous_() {
-    return Zipper::previous;
-  }
-
-  /**
-   * Inserts an element to the left of the focus, then moves the focus to the new element.
-   *
-   * @param a A new element to insert into this zipper.
-   * @return A new zipper with the given element in focus, and the current focus element on its right.
-   */
-  public Zipper<A> insertLeft(final A a) {
-    return zipper(left, a, right.cons(focus));
-  }
-
-  /**
-   * Inserts an element to the right of the focus, then moves the focus to the new element.
-   *
-   * @param a A new element to insert into this zipper.
-   * @return A new zipper with the given element in focus, and the current focus element on its left.
-   */
-  public Zipper<A> insertRight(final A a) {
-    return zipper(left.cons(focus), a, right);
-  }
-
-  /**
-   * Possibly deletes the element at the focus, then moves the element on the left into focus.
-   * If no element is on the left, focus on the element to the right.
-   * Returns None if the focus element is the only element in this zipper.
-   *
-   * @return A new zipper with this zipper's focus element removed, or None if deleting the focus element
-   *         would cause the zipper to be empty.
-   */
-  public Option<Zipper<A>> deleteLeft() {
-    return left.isEmpty() && right.isEmpty()
-           ? Option.none()
-           : some(zipper(left.isEmpty() ? left : left.tail()._1(),
-                         left.isEmpty() ? right.head() : left.head(),
-                         left.isEmpty() ? right.tail()._1() : right));
-  }
-
-  /**
-   * Possibly deletes the element at the focus, then moves the element on the right into focus.
-   * If no element is on the right, focus on the element to the left.
-   * Returns None if the focus element is the only element in this zipper.
-   *
-   * @return A new zipper with this zipper's focus element removed, or None if deleting the focus element
-   *         would cause the zipper to be empty.
-   */
-  public Option<Zipper<A>> deleteRight() {
-    return left.isEmpty() && right.isEmpty()
-           ? Option.none()
-           : some(zipper(right.isEmpty() ? left.tail()._1() : left,
-                         right.isEmpty() ? left.head() : right.head(),
-                         right.isEmpty() ? right : right.tail()._1()));
-  }
-
-  /**
-   * Deletes all elements in the zipper except the focus.
-   *
-   * @return A new zipper with the focus element as the only element.
-   */
-  public Zipper<A> deleteOthers() {
-    final Stream<A> nil = nil();
-    return zipper(nil, focus, nil);
-  }
-
-  /**
-   * Returns the length of this zipper.
-   *
-   * @return the length of this zipper.
-   */
-  public int length() {
-    return foldRight(Function.constant(Integers.add.f(1)), 0);
-  }
-
-  /**
-   * Returns whether the focus is on the first element.
-   *
-   * @return true if the focus is on the first element, otherwise false.
-   */
-  public boolean atStart() {
-    return left.isEmpty();
-  }
-
-  /**
-   * Returns whether the focus is on the last element.
-   *
-   * @return true if the focus is on the last element, otherwise false.
-   */
-  public boolean atEnd() {
-    return right.isEmpty();
-  }
-
-  /**
-   * Creates a zipper of variations of this zipper, in which each element is focused,
-   * with this zipper as the focus of the zipper of zippers (comonad pattern).
-   *
-   * @return a zipper of variations of the provided zipper, in which each element is focused,
-   *         with this zipper as the focus of the zipper of zippers.
-   */
-  public Zipper<Zipper<A>> positions() {
-    final Stream<Zipper<A>> left = Stream.unfold(
-            p -> p.previous().map(join(P.p2())), this);
-    final Stream<Zipper<A>> right = Stream.unfold(
-            p -> p.next().map(join(P.p2())), this);
-
-    return zipper(left, this, right);
-  }
-
-  /**
-   * Maps over variations of this zipper, such that the given function is applied to each variation (comonad pattern).
-   *
-   * @param f The comonadic function to apply for each variation of this zipper.
-   * @return A new zipper, with the given function applied for each variation of this zipper.
-   */
-  public <B> Zipper<B> cobind(final F<Zipper<A>, B> f) {
-    return positions().map(f);
-  }
-
-  /**
-   * Zips the elements of this zipper with a boolean that indicates whether that element has focus.
-   * All of the booleans will be false, except the focused element.
-   *
-   * @return A new zipper of pairs, with each element of this zipper paired with a boolean that is true if that
-   *         element has focus, and false otherwise.
-   */
-  public Zipper<P2<A, Boolean>> zipWithFocus() {
-    return zipper(left.zip(repeat(false)), P.p(focus, true), right.zip(repeat(false)));
-  }
-
-  /**
-   * Move the focus to the specified index.
-   *
-   * @param n The index to which to move the focus.
-   * @return A new zipper with the focus moved to the specified index, or none if there is no such index.
-   */
-  public Option<Zipper<A>> move(final int n) {
-    final int ll = left.length();
-    final int rl = right.length();
-    Option<Zipper<A>> p = some(this);
-    if (n < 0 || n >= length())
-      return none();
-    else if (ll >= n)
-      for (int i = ll - n; i > 0; i--)
-        p = p.bind(Zipper.previous_());
-    else if (rl >= n)
-      for (int i = rl - n; i > 0; i--)
-        p = p.bind(Zipper.next_());
-    return p;
-  }
-
-  /**
-   * A first-class version of the move function.
-   *
-   * @return A function that moves the focus of the given zipper to the given index.
-   */
-  public static <A> F<Integer, F<Zipper<A>, Option<Zipper<A>>>> move() {
-    return curry((i, a) -> a.move(i));
-  }
-
-  /**
-   * Moves the focus to the element matching the given predicate, if present.
-   *
-   * @param p A predicate to match.
-   * @return A new zipper with the nearest matching element focused if it is present in this zipper.
-   */
-  public Option<Zipper<A>> find(final F<A, Boolean> p) {
-    if (p.f(focus()))
-      return some(this);
-    else {
-      final Zipper<Zipper<A>> ps = positions();
-      return ps.lefts().interleave(ps.rights()).find(zipper -> p.f(zipper.focus()));
-    }
-  }
-
-  /**
-   * Returns the index of the focus.
-   *
-   * @return the index of the focus.
-   */
-  public int index() {
-    return left.length();
-  }
-
-  /**
-   * Move the focus to the next element. If the last element is focused, loop to the first element.
-   *
-   * @return A new zipper with the next element focused, unless the last element is currently focused, in which case
-   *         the first element becomes focused.
-   */
-  public Zipper<A> cycleNext() {
-    if (left.isEmpty() && right.isEmpty())
-      return this;
-    else if (right.isEmpty()) {
-      final Stream<A> xs = left.reverse();
-      return zipper(Stream.nil(), xs.head(), xs.tail()._1().snoc(P.p(focus)));
-    } else
-      return tryNext();
-  }
-
-  /**
-   * Move the focus to the previous element. If the first element is focused, loop to the last element.
-   *
-   * @return A new zipper with the previous element focused, unless the first element is currently focused,
-   *         in which case the last element becomes focused.
-   */
-  public Zipper<A> cyclePrevious() {
-    if (left.isEmpty() && right.isEmpty())
-      return this;
-    else if (left.isEmpty()) {
-      final Stream<A> xs = right.reverse();
-      return zipper(xs.tail()._1().snoc(P.p(focus)), xs.head(), Stream.nil());
-    } else
-      return tryPrevious();
-  }
-
-  /**
-   * Possibly deletes the element at the focus, then move the element on the left into focus. If no element is on the
-   * left, focus on the last element. If the deletion will cause the list to be empty, return None.
-   *
-   * @return A new zipper with the focused element removed, and focus on the previous element to the left, or the last
-   *         element if there is no element to the left.
-   */
-  public Option<Zipper<A>> deleteLeftCycle() {
-    if (left.isEmpty() && right.isEmpty())
-      return none();
-    else if (left.isNotEmpty())
-      return some(zipper(left.tail()._1(), left.head(), right));
-    else {
-      final Stream<A> xs = right.reverse();
-      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
-    }
-  }
-
-  /**
-   * Possibly deletes the element at the focus, then move the element on the right into focus. If no element is on the
-   * right, focus on the first element. If the deletion will cause the list to be empty, return None.
-   *
-   * @return A new zipper with the focused element removed, and focus on the next element to the right, or the first
-   *         element if there is no element to the right.
-   */
-  public Option<Zipper<A>> deleteRightCycle() {
-    if (left.isEmpty() && right.isEmpty())
-      return none();
-    else if (right.isNotEmpty())
-      return some(zipper(left, right.head(), right.tail()._1()));
-    else {
-      final Stream<A> xs = left.reverse();
-      return some(zipper(Stream.nil(), xs.head(), xs.tail()._1()));
-    }
-  }
-
-  /**
-   * Replaces the element in focus with the given element.
-   *
-   * @param a An element to replace the focused element with.
-   * @return A new zipper with the given element in focus.
-   */
-  public Zipper<A> replace(final A a) {
-    return zipper(left, a, right);
-  }
-
-  /**
-   * Returns the Stream representation of this zipper.
-   *
-   * @return A stream that contains all the elements of this zipper.
-   */
-  public Stream<A> toStream() {
-    return left.reverse().snoc(P.p(focus)).append(right);
-  }
-
-  /**
-   * Returns a Stream of the elements to the left of focus.
-   *
-   * @return a Stream of the elements to the left of focus.
-   */
-  public Stream<A> lefts() {
-    return left;
-  }
-
-  /**
-   * Returns a Stream of the elements to the right of focus.
-   *
-   * @return a Stream of the elements to the right of focus.
-   */
-  public Stream<A> rights() {
-    return right;
-  }
-
-  /**
-   * Zips this Zipper with another, applying the given function lock-step over both zippers in both directions.
-   * The structure of the resulting Zipper is the structural intersection of the two Zippers.
-   *
-   * @param bs A Zipper to zip this one with.
-   * @param f  A function with which to zip together the two Zippers.
-   * @return The result of applying the given function over this Zipper and the given Zipper, location-wise.
-   */
-  public <B, C> Zipper<C> zipWith(final Zipper<B> bs, final F2<A, B, C> f) {
-    return F2Functions.zipZipperM(f).f(this, bs);
-  }
-
-
-  /**
-   * Zips this Zipper with another, applying the given function lock-step over both zippers in both directions.
-   * The structure of the resulting Zipper is the structural intersection of the two Zippers.
-   *
-   * @param bs A Zipper to zip this one with.
-   * @param f  A function with which to zip together the two Zippers.
-   * @return The result of applying the given function over this Zipper and the given Zipper, location-wise.
-   */
-  public <B, C> Zipper<C> zipWith(final Zipper<B> bs, final F<A, F<B, C>> f) {
-    return zipWith(bs, uncurryF2(f));
-  }
-
-  /**
-   * Returns an iterator of all the positions of this Zipper, starting from the leftmost position.
-   *
-   * @return An iterator of all the positions of this Zipper, starting from the leftmost position.
-   */
-  public Iterator<Zipper<A>> iterator() { return positions().toStream().iterator(); }
-}
+package fj.data;
+
+import fj.*;
+import fj.function.Integers;
+
+import java.util.Iterator;
+
+import static fj.Function.compose;
+import static fj.Function.curry;
+import static fj.Function.flip;
+import static fj.Function.join;
+import static fj.Function.uncurryF2;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+import static fj.data.Stream.nil;
+import static fj.data.Stream.repeat;
+
+/**
+ * Provides a pointed stream, which is a non-empty zipper-like stream structure that tracks an index (focus)
+ * position in a stream. Focus can be moved forward and backwards through the stream, elements can be inserted
+ * before or after the focused position, and the focused item can be deleted.
+ * <p/>
+ * Based on the pointedlist library by Jeff Wheeler.
+ */
+public final class Zipper<A> implements Iterable<Zipper<A>> {
+  private final Stream<A> left;
+  private final A focus;
+  private final Stream<A> right;
+
+  private Zipper(final Stream<A> left, final A focus, final Stream<A> right) {
+    this.left = left;
+    this.focus = focus;
+    this.right = right;
+  }
+
+
+  /**
+   * Creates a new Zipper with the given streams before and after the focus, and the given focused item.
+   *
+   * @param left  The stream of elements before the focus.
+   * @param focus The element under focus.
+   * @param right The stream of elements after the focus.
+   * @return a new Zipper with the given streams before and after the focus, and the given focused item.
+   */
+  public static <A> Zipper<A> zipper(final Stream<A> left, final A focus, final Stream<A> right) {
+    return new Zipper<>(left, focus, right);
+  }
+
+  /**
+   * Creates a new Zipper from the given triple.
+   *
+   * @param p A triple of the elements before the focus, the focus element, and the elements after the focus,
+   *          respectively.
+   * @return a new Zipper created from the given triple.
+   */
+  public static <A> Zipper<A> zipper(final P3<Stream<A>, A, Stream<A>> p) {
+    return new Zipper<>(p._1(), p._2(), p._3());
+  }
+
+  /**
+   * First-class constructor of zippers.
+   *
+   * @return A function that yields a new zipper given streams on the left and right and a focus element.
+   */
+  public static <A> F3<Stream<A>, A, Stream<A>, Zipper<A>> zipper() {
+    return Zipper::zipper;
+  }
+
+  /**
+   * Returns the product-3 representation of this Zipper.
+   *
+   * @return the product-3 representation of this Zipper.
+   */
+  public P3<Stream<A>, A, Stream<A>> p() {
+    return P.p(left, focus, right);
+  }
+
+  /**
+   * A first-class function that yields the product-3 representation of a given Zipper.
+   *
+   * @return A first-class function that yields the product-3 representation of a given Zipper.
+   */
+  public static <A> F<Zipper<A>, P3<Stream<A>, A, Stream<A>>> p_() {
+    return Zipper::p;
+  }
+
+  /**
+   * An Ord instance for Zippers.
+   *
+   * @param o An Ord instance for the element type.
+   * @return An Ord instance for Zippers.
+   */
+  public static <A> Ord<Zipper<A>> ord(final Ord<A> o) {
+    final Ord<Stream<A>> so = Ord.streamOrd(o);
+    return Ord.p3Ord(so, o, so).contramap(Zipper.p_());
+  }
+
+  @Override
+  public final boolean equals(Object other) {
+    return Equal.equals0(Zipper.class, this, other, () -> Equal.zipperEqual(Equal.anyEqual()));
+  }
+
+  @Override
+  public final int hashCode() {
+    return Hash.zipperHash(Hash.<A>anyHash()).hash(this);
+  }
+
+  /**
+   * An Equal instance for Zippers.
+   *
+   * @param e An Equal instance for the element type.
+   * @return An Equal instance for Zippers.
+   */
+  public static <A> Equal<Zipper<A>> eq(final Equal<A> e) {
+    final Equal<Stream<A>> se = Equal.streamEqual(e);
+    return Equal.p3Equal(se, e, se).contramap(Zipper.p_());
+  }
+
+  /**
+   * A Show instance for Zippers.
+   *
+   * @param s A Show instance for the element type.
+   * @return A Show instance for Zippers.
+   */
+  public static <A> Show<Zipper<A>> show(final Show<A> s) {
+    final Show<Stream<A>> ss = Show.streamShow(s);
+    return Show.p3Show(ss, s, ss).contramap(Zipper.p_());
+  }
+
+  /**
+   * Maps the given function across the elements of this zipper (covariant functor pattern).
+   *
+   * @param f A function to map across this zipper.
+   * @return A new zipper with the given function applied to all elements.
+   */
+  public <B> Zipper<B> map(final F<A, B> f) {
+    return zipper(left.map(f), f.f(focus), right.map(f));
+  }
+
+  /**
+   * Performs a right-fold reduction across this zipper.
+   *
+   * @param f The function to apply on each element of this zipper.
+   * @param z The beginning value to start the application from.
+   * @return the final result after the right-fold reduction.
+   */
+  public <B> B foldRight(final F<A, F<B, B>> f, final B z) {
+    return left.foldLeft(flip(f),
+                         right.cons(focus).foldRight(compose(
+                             Function.<P1<B>, B, B>andThen().f(P1.__1()), f), z));
+  }
+
+  /**
+   * Creates a new zipper with a single element.
+   *
+   * @param a The focus element of the new zipper.
+   * @return a new zipper with a single element which is in focus.
+   */
+  public static <A> Zipper<A> single(final A a) {
+    return zipper(Stream.nil(), a, Stream.nil());
+  }
+
+  /**
+   * Possibly create a zipper if the provided stream has at least one element, otherwise None.
+   * The provided stream's head will be the focus of the zipper, and the rest of the stream will follow
+   * on the right side.
+   *
+   * @param a The stream from which to create a zipper.
+   * @return a new zipper if the provided stream has at least one element, otherwise None.
+   */
+  @SuppressWarnings("IfMayBeConditional")
+  public static <A> Option<Zipper<A>> fromStream(final Stream<A> a) {
+    if (a.isEmpty())
+      return none();
+    else
+      return some(zipper(Stream.nil(), a.head(), a.tail()._1()));
+  }
+
+  /**
+   * Possibly create a zipper if the provided stream has at least one element, otherwise None.
+   * The provided stream's last element will be the focus of the zipper, following the rest of the stream in order,
+   * to the left.
+   *
+   * @param a The stream from which to create a zipper.
+   * @return a new zipper if the provided stream has at least one element, otherwise None.
+   */
+  public static <A> Option<Zipper<A>> fromStreamEnd(final Stream<A> a) {
+    if (a.isEmpty())
+      return none();
+    else {
+      final Stream<A> xs = a.reverse();
+      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
+    }
+  }
+
+  /**
+   * Returns the focus element of this zipper.
+   *
+   * @return the focus element of this zipper.
+   */
+  public A focus() {
+    return focus;
+  }
+
+  /**
+   * Possibly moves the focus to the next element in the list.
+   *
+   * @return An optional zipper with the focus moved one element to the right, if there are elements to the right of
+   *         focus, otherwise None.
+   */
+  public Option<Zipper<A>> next() {
+    return right.isEmpty() ? Option.none() : some(tryNext());
+  }
+
+  /**
+   * Attempts to move the focus to the next element, or throws an error if there are no more elements.
+   *
+   * @return A zipper with the focus moved one element to the right, if there are elements to the right of
+   *         focus, otherwise throws an error.
+   */
+  public Zipper<A> tryNext() {
+    if (right.isEmpty())
+      throw new Error("Tried next at the end of a zipper.");
+    else
+      return zipper(left.cons(focus), right.head(), right.tail()._1());
+  }
+
+  /**
+   * Possibly moves the focus to the previous element in the list.
+   *
+   * @return An optional zipper with the focus moved one element to the left, if there are elements to the left of
+   *         focus, otherwise None.
+   */
+  public Option<Zipper<A>> previous() {
+    return left.isEmpty() ? Option.none() : some(tryPrevious());
+  }
+
+  /**
+   * Attempts to move the focus to the previous element, or throws an error if there are no more elements.
+   *
+   * @return A zipper with the focus moved one element to the left, if there are elements to the left of
+   *         focus, otherwise throws an error.
+   */
+  public Zipper<A> tryPrevious() {
+    if (left.isEmpty())
+      throw new Error("Tried previous at the beginning of a zipper.");
+    else
+      return zipper(left.tail()._1(), left.head(), right.cons(focus));
+  }
+
+  /**
+   * First-class version of the next() function.
+   *
+   * @return A function that moves the given zipper's focus to the next element.
+   */
+  public static <A> F<Zipper<A>, Option<Zipper<A>>> next_() {
+    return Zipper::next;
+  }
+
+  /**
+   * First-class version of the previous() function.
+   *
+   * @return A function that moves the given zipper's focus to the previous element.
+   */
+  public static <A> F<Zipper<A>, Option<Zipper<A>>> previous_() {
+    return Zipper::previous;
+  }
+
+  /**
+   * Inserts an element to the left of the focus, then moves the focus to the new element.
+   *
+   * @param a A new element to insert into this zipper.
+   * @return A new zipper with the given element in focus, and the current focus element on its right.
+   */
+  public Zipper<A> insertLeft(final A a) {
+    return zipper(left, a, right.cons(focus));
+  }
+
+  /**
+   * Inserts an element to the right of the focus, then moves the focus to the new element.
+   *
+   * @param a A new element to insert into this zipper.
+   * @return A new zipper with the given element in focus, and the current focus element on its left.
+   */
+  public Zipper<A> insertRight(final A a) {
+    return zipper(left.cons(focus), a, right);
+  }
+
+  /**
+   * Possibly deletes the element at the focus, then moves the element on the left into focus.
+   * If no element is on the left, focus on the element to the right.
+   * Returns None if the focus element is the only element in this zipper.
+   *
+   * @return A new zipper with this zipper's focus element removed, or None if deleting the focus element
+   *         would cause the zipper to be empty.
+   */
+  public Option<Zipper<A>> deleteLeft() {
+    return left.isEmpty() && right.isEmpty()
+           ? Option.none()
+           : some(zipper(left.isEmpty() ? left : left.tail()._1(),
+                         left.isEmpty() ? right.head() : left.head(),
+                         left.isEmpty() ? right.tail()._1() : right));
+  }
+
+  /**
+   * Possibly deletes the element at the focus, then moves the element on the right into focus.
+   * If no element is on the right, focus on the element to the left.
+   * Returns None if the focus element is the only element in this zipper.
+   *
+   * @return A new zipper with this zipper's focus element removed, or None if deleting the focus element
+   *         would cause the zipper to be empty.
+   */
+  public Option<Zipper<A>> deleteRight() {
+    return left.isEmpty() && right.isEmpty()
+           ? Option.none()
+           : some(zipper(right.isEmpty() ? left.tail()._1() : left,
+                         right.isEmpty() ? left.head() : right.head(),
+                         right.isEmpty() ? right : right.tail()._1()));
+  }
+
+  /**
+   * Deletes all elements in the zipper except the focus.
+   *
+   * @return A new zipper with the focus element as the only element.
+   */
+  public Zipper<A> deleteOthers() {
+    final Stream<A> nil = nil();
+    return zipper(nil, focus, nil);
+  }
+
+  /**
+   * Returns the length of this zipper.
+   *
+   * @return the length of this zipper.
+   */
+  public int length() {
+    return foldRight(Function.constant(Integers.add.f(1)), 0);
+  }
+
+  /**
+   * Returns whether the focus is on the first element.
+   *
+   * @return true if the focus is on the first element, otherwise false.
+   */
+  public boolean atStart() {
+    return left.isEmpty();
+  }
+
+  /**
+   * Returns whether the focus is on the last element.
+   *
+   * @return true if the focus is on the last element, otherwise false.
+   */
+  public boolean atEnd() {
+    return right.isEmpty();
+  }
+
+  /**
+   * Creates a zipper of variations of this zipper, in which each element is focused,
+   * with this zipper as the focus of the zipper of zippers (comonad pattern).
+   *
+   * @return a zipper of variations of the provided zipper, in which each element is focused,
+   *         with this zipper as the focus of the zipper of zippers.
+   */
+  public Zipper<Zipper<A>> positions() {
+    final Stream<Zipper<A>> left = Stream.unfold(
+            p -> p.previous().map(join(P.p2())), this);
+    final Stream<Zipper<A>> right = Stream.unfold(
+            p -> p.next().map(join(P.p2())), this);
+
+    return zipper(left, this, right);
+  }
+
+  /**
+   * Maps over variations of this zipper, such that the given function is applied to each variation (comonad pattern).
+   *
+   * @param f The comonadic function to apply for each variation of this zipper.
+   * @return A new zipper, with the given function applied for each variation of this zipper.
+   */
+  public <B> Zipper<B> cobind(final F<Zipper<A>, B> f) {
+    return positions().map(f);
+  }
+
+  /**
+   * Zips the elements of this zipper with a boolean that indicates whether that element has focus.
+   * All of the booleans will be false, except the focused element.
+   *
+   * @return A new zipper of pairs, with each element of this zipper paired with a boolean that is true if that
+   *         element has focus, and false otherwise.
+   */
+  public Zipper<P2<A, Boolean>> zipWithFocus() {
+    return zipper(left.zip(repeat(false)), P.p(focus, true), right.zip(repeat(false)));
+  }
+
+  /**
+   * Move the focus to the specified index.
+   *
+   * @param n The index to which to move the focus.
+   * @return A new zipper with the focus moved to the specified index, or none if there is no such index.
+   */
+  public Option<Zipper<A>> move(final int n) {
+    final int ll = left.length();
+    final int rl = right.length();
+    Option<Zipper<A>> p = some(this);
+    if (n < 0 || n >= length())
+      return none();
+    else if (ll >= n)
+      for (int i = ll - n; i > 0; i--)
+        p = p.bind(Zipper.previous_());
+    else if (rl >= n)
+      for (int i = rl - n; i > 0; i--)
+        p = p.bind(Zipper.next_());
+    return p;
+  }
+
+  /**
+   * A first-class version of the move function.
+   *
+   * @return A function that moves the focus of the given zipper to the given index.
+   */
+  public static <A> F<Integer, F<Zipper<A>, Option<Zipper<A>>>> move() {
+    return curry((i, a) -> a.move(i));
+  }
+
+  /**
+   * Moves the focus to the element matching the given predicate, if present.
+   *
+   * @param p A predicate to match.
+   * @return A new zipper with the nearest matching element focused if it is present in this zipper.
+   */
+  public Option<Zipper<A>> find(final F<A, Boolean> p) {
+    if (p.f(focus()))
+      return some(this);
+    else {
+      final Zipper<Zipper<A>> ps = positions();
+      return ps.lefts().interleave(ps.rights()).find(zipper -> p.f(zipper.focus()));
+    }
+  }
+
+  /**
+   * Returns the index of the focus.
+   *
+   * @return the index of the focus.
+   */
+  public int index() {
+    return left.length();
+  }
+
+  /**
+   * Move the focus to the next element. If the last element is focused, loop to the first element.
+   *
+   * @return A new zipper with the next element focused, unless the last element is currently focused, in which case
+   *         the first element becomes focused.
+   */
+  public Zipper<A> cycleNext() {
+    if (left.isEmpty() && right.isEmpty())
+      return this;
+    else if (right.isEmpty()) {
+      final Stream<A> xs = left.reverse();
+      return zipper(Stream.nil(), xs.head(), xs.tail()._1().snoc(P.p(focus)));
+    } else
+      return tryNext();
+  }
+
+  /**
+   * Move the focus to the previous element. If the first element is focused, loop to the last element.
+   *
+   * @return A new zipper with the previous element focused, unless the first element is currently focused,
+   *         in which case the last element becomes focused.
+   */
+  public Zipper<A> cyclePrevious() {
+    if (left.isEmpty() && right.isEmpty())
+      return this;
+    else if (left.isEmpty()) {
+      final Stream<A> xs = right.reverse();
+      return zipper(xs.tail()._1().snoc(P.p(focus)), xs.head(), Stream.nil());
+    } else
+      return tryPrevious();
+  }
+
+  /**
+   * Possibly deletes the element at the focus, then move the element on the left into focus. If no element is on the
+   * left, focus on the last element. If the deletion will cause the list to be empty, return None.
+   *
+   * @return A new zipper with the focused element removed, and focus on the previous element to the left, or the last
+   *         element if there is no element to the left.
+   */
+  public Option<Zipper<A>> deleteLeftCycle() {
+    if (left.isEmpty() && right.isEmpty())
+      return none();
+    else if (left.isNotEmpty())
+      return some(zipper(left.tail()._1(), left.head(), right));
+    else {
+      final Stream<A> xs = right.reverse();
+      return some(zipper(xs.tail()._1(), xs.head(), Stream.nil()));
+    }
+  }
+
+  /**
+   * Possibly deletes the element at the focus, then move the element on the right into focus. If no element is on the
+   * right, focus on the first element. If the deletion will cause the list to be empty, return None.
+   *
+   * @return A new zipper with the focused element removed, and focus on the next element to the right, or the first
+   *         element if there is no element to the right.
+   */
+  public Option<Zipper<A>> deleteRightCycle() {
+    if (left.isEmpty() && right.isEmpty())
+      return none();
+    else if (right.isNotEmpty())
+      return some(zipper(left, right.head(), right.tail()._1()));
+    else {
+      final Stream<A> xs = left.reverse();
+      return some(zipper(Stream.nil(), xs.head(), xs.tail()._1()));
+    }
+  }
+
+  /**
+   * Replaces the element in focus with the given element.
+   *
+   * @param a An element to replace the focused element with.
+   * @return A new zipper with the given element in focus.
+   */
+  public Zipper<A> replace(final A a) {
+    return zipper(left, a, right);
+  }
+
+  /**
+   * Returns the Stream representation of this zipper.
+   *
+   * @return A stream that contains all the elements of this zipper.
+   */
+  public Stream<A> toStream() {
+    return left.reverse().snoc(P.p(focus)).append(right);
+  }
+
+  /**
+   * Returns a Stream of the elements to the left of focus.
+   *
+   * @return a Stream of the elements to the left of focus.
+   */
+  public Stream<A> lefts() {
+    return left;
+  }
+
+  /**
+   * Returns a Stream of the elements to the right of focus.
+   *
+   * @return a Stream of the elements to the right of focus.
+   */
+  public Stream<A> rights() {
+    return right;
+  }
+
+  /**
+   * Zips this Zipper with another, applying the given function lock-step over both zippers in both directions.
+   * The structure of the resulting Zipper is the structural intersection of the two Zippers.
+   *
+   * @param bs A Zipper to zip this one with.
+   * @param f  A function with which to zip together the two Zippers.
+   * @return The result of applying the given function over this Zipper and the given Zipper, location-wise.
+   */
+  public <B, C> Zipper<C> zipWith(final Zipper<B> bs, final F2<A, B, C> f) {
+    return f.zipZipperM().f(this, bs);
+  }
+
+
+  /**
+   * Zips this Zipper with another, applying the given function lock-step over both zippers in both directions.
+   * The structure of the resulting Zipper is the structural intersection of the two Zippers.
+   *
+   * @param bs A Zipper to zip this one with.
+   * @param f  A function with which to zip together the two Zippers.
+   * @return The result of applying the given function over this Zipper and the given Zipper, location-wise.
+   */
+  public <B, C> Zipper<C> zipWith(final Zipper<B> bs, final F<A, F<B, C>> f) {
+    return zipWith(bs, uncurryF2(f));
+  }
+
+  /**
+   * Returns an iterator of all the positions of this Zipper, starting from the leftmost position.
+   *
+   * @return An iterator of all the positions of this Zipper, starting from the leftmost position.
+   */
+  public Iterator<Zipper<A>> iterator() { return positions().toStream().iterator(); }
+}
diff --git a/core/src/main/java/fj/data/fingertrees/FingerTree.java b/core/src/main/java/fj/data/fingertrees/FingerTree.java
index 160b5508..ab0effb0 100644
--- a/core/src/main/java/fj/data/fingertrees/FingerTree.java
+++ b/core/src/main/java/fj/data/fingertrees/FingerTree.java
@@ -1,268 +1,268 @@
-package fj.data.fingertrees;
-
-import fj.*;
-import fj.data.Option;
-import fj.data.Seq;
-import fj.data.Stream;
-
-import static fj.Monoid.intAdditionMonoid;
-import static fj.Monoid.intMaxMonoid;
-import static fj.data.Stream.nil;
-
-/**
- * Provides 2-3 finger trees, a functional representation of persistent sequences supporting access to the ends in
- * amortized O(1) time. Concatenation and splitting time is O(log n) in the size of the smaller piece.
- * A general purpose data structure that can serve as a sequence, priority queue, search tree, priority search queue
- * and more.
- * <p/>
- * This class serves as a datastructure construction kit, rather than a datastructure in its own right. By supplying
- * a monoid, a measurement function, insertion, deletion, and so forth, any purely functional datastructure can be
- * emulated. See {@link Seq} for an example.
- * <p/>
- * Based on "Finger trees: a simple general-purpose data structure", by Ralf Hinze and Ross Paterson.
- *
- * @param <V> The monoidal type with which to annotate nodes.
- * @param <A> The type of the tree's elements.
- */
-public abstract class FingerTree<V, A> {
-  private final Measured<V, A> m;
-
-  /**
-   * Folds the tree to the right with the given function and the given initial element.
-   *
-   * @param f A function with which to fold the tree.
-   * @param z An initial element to apply to the fold.
-   * @return A reduction of this tree by applying the given function, associating to the right.
-   */
-  public abstract <B> B foldRight(final F<A, F<B, B>> f, final B z);
-
-    public final <B> B foldRight(final F2<A, B, B> f, final B z) {
-        return foldRight(F2Functions.curry(f), z);
-    }
-
-  /**
-   * Folds the tree to the right with the given function.
-   *
-   * @param f A function with which to fold the tree.
-   * @return A reduction of this tree by applying the given function, associating to the right.
-   */
-  public abstract A reduceRight(final F<A, F<A, A>> f);
-
-  /**
-   * Folds the tree to the left with the given function and the given initial element.
-   *
-   * @param f A function with which to fold the tree.
-   * @param z An initial element to apply to the fold.
-   * @return A reduction of this tree by applying the given function, associating to the left.
-   */
-  public abstract <B> B foldLeft(final F<B, F<A, B>> f, final B z);
-
-    public final <B> B foldLeft(final F2<B, A, B> f, final B z) {
-        return foldLeft(F2Functions.curry(f), z);
-    }
-
-  /**
-   * Folds the tree to the left with the given function.
-   *
-   * @param f A function with which to fold the tree.
-   * @return A reduction of this tree by applying the given function, associating to the right.
-   */
-  public abstract A reduceLeft(final F<A, F<A, A>> f);
-
-  /**
-   * Maps the given function across this tree, measuring with the given Measured instance.
-   *
-   * @param f A function to map across the values of this tree.
-   * @param m A measuring with which to annotate the tree.
-   * @return A new tree with the same structure as this tree, with each element transformed by the given function,
-   *         and nodes annotated according to the given measuring.
-   */
-  public abstract <B> FingerTree<V, B> map(final F<A, B> f, final Measured<V, B> m);
-
-    public final <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
-        FingerTree<V, A> tree = new Empty<>(m);
-        return foldLeft((acc, a) -> f.f(a) ? acc.snoc(a) : acc, tree);
-    }
-
-  /**
-   * Returns the sum of this tree's annotations.
-   *
-   * @return the sum of this tree's annotations.
-   */
-  public abstract V measure();
-
-  /**
-   * Indicates whether this tree is empty.
-   *
-   * @return true if this tree is the empty tree, otherwise false.
-   */
-  public final boolean isEmpty() {
-    return this instanceof Empty;
-  }
-  
-  public final Measured<V, A> measured() {
-    return m;
-  }
-
-  /**
-   * Provides pattern matching on trees. This is the Church encoding of the FingerTree datatype.
-   *
-   * @param empty  The function to apply to this empty tree.
-   * @param single A function to apply if this tree contains a single element.
-   * @param deep   A function to apply if this tree contains more than one element.
-   * @return The result of the function that matches this tree structurally, applied to this tree.
-   */
-  public abstract <B> B match(final F<Empty<V, A>, B> empty, final F<Single<V, A>, B> single,
-                              final F<Deep<V, A>, B> deep);
-
-  FingerTree(final Measured<V, A> m) {
-    this.m = m;
-  }
-
-  /**
-   * Constructs a Measured instance for the element type, given a monoid and a measuring function.
-   *
-   * @param monoid  A monoid for the measures.
-   * @param measure A function with which to measure element values.
-   * @return A Measured instance for the given element type, that uses the given monoid and measuring function.
-   */
-  public static <V, A> Measured<V, A> measured(final Monoid<V> monoid, final F<A, V> measure) {
-    return Measured.measured(monoid, measure);
-  }
-
-  /**
-   * Returns a builder of trees and tree components that annotates them using the given Measured instance.
-   *
-   * @param m A Measured instance with which to annotate trees, digits, and nodes.
-   * @return A builder of trees and tree components that annotates them using the given Measured instance.
-   */
-  public static <V, A> MakeTree<V, A> mkTree(final Measured<V, A> m) {
-    return new MakeTree<>(m);
-  }
-
-  /**
-   * Adds the given element to this tree as the first element.
-   *
-   * @param a The element to add to the front of this tree.
-   * @return A new tree with the given element at the front.
-   */
-  public abstract FingerTree<V, A> cons(final A a);
-
-  /**
-   * Adds the given element to this tree as the last element.
-   *
-   * @param a The element to add to the end of this tree.
-   * @return A new tree with the given element at the end.
-   */
-  public abstract FingerTree<V, A> snoc(final A a);
-
-  /**
-   * The first element of this tree. This is an O(1) operation.
-   *
-   * @return The first element if this tree is nonempty, otherwise throws an error.
-   */
-  public abstract A head();
-
-  public final Option<A> headOption() {
-      return isEmpty() ? Option.none() : Option.some(head());
-  }
-
-  /**
-   * Performs a reduction on this finger tree using the given arguments.
-   *
-   * @param nil  The value to return if this finger tree is empty.
-   * @param cons The function to apply to the head and tail of this finger tree  if it is not empty.
-   * @return A reduction on this finger tree.
-   */
-  public final <B> B uncons(B nil, F2<A, FingerTree<V, A>, B> cons) {
-    return isEmpty() ? nil : cons.f(head(), tail());
-  }
-
-
-  /**
-   * The last element of this tree. This is an O(1) operation.
-   *
-   * @return The last element if this tree is nonempty, otherwise throws an error.
-   */
-  public abstract A last();
-
-  /**
-   * The tree without the first element. This is an O(1) operation.
-   *
-   * @return The tree without the first element if this tree is nonempty, otherwise throws an error.
-   */
-  public abstract FingerTree<V, A> tail();
-
-  /**
-   * The tree without the last element. This is an O(1) operation.
-   *
-   * @return The tree without the last element if this tree is nonempty, otherwise throws an error.
-   */
-  public abstract FingerTree<V, A> init();
-
-  /**
-   * Appends one finger tree to another.
-   *
-   * @param t A finger tree to append to this one.
-   * @return A new finger tree which is a concatenation of this tree and the given tree.
-   */
-  public abstract FingerTree<V, A> append(final FingerTree<V, A> t);
-
-  /**
-   * Splits this tree into a pair of subtrees at the point where the given predicate, based on the measure,
-   * changes from <code>false</code> to <code>true</code>. This is a O(log(n)) operation.
-   *
-   * @return Pair: the subtree containing elements before the point where <code>pred</code> first holds and the subtree
-   *   containing element at and after the point where <code>pred</code> first holds. Empty if <code>pred</code> never holds.
-   */
-  public final P2<FingerTree<V, A>, FingerTree<V, A>> split(final F<V, Boolean> predicate) {
-    if (!isEmpty() && predicate.f(measure())) {
-      final P3<FingerTree<V, A>, A, FingerTree<V, A>> lxr = split1(predicate);
-      return P.p(lxr._1(), lxr._3().cons(lxr._2()));
-    } else {
-      return P.p(this, mkTree(m).empty());
-    }
-  }
-
-  /**
-   * Like <code>split</code>, but returns the element where <code>pred</code> first holds separately.
-   *
-   * Throws an error if the tree is empty.
-   */
-  public final P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate) {
-    return split1(predicate, measured().zero());
-  }
-
-  abstract P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate, final V acc);
-
-  public abstract P2<Integer, A> lookup(final F<V, Integer> o, final int i);
-
-    public abstract int length();
-
-    public static <A> FingerTree<Integer, A> emptyIntAddition() {
-      return empty(intAdditionMonoid, Function.constant(1));
-    }
-
-  /**
-   * Creates an empty finger tree with elements of type A and node annotations
-   * of type V.
-   *
-   * @param m A monoid to combine node annotations
-   * @param f Function to convert node element to annotation.
-   * @return An empty finger tree.
-   */
-  public static <V, A> FingerTree<V, A> empty(Monoid<V> m, F<A, V> f) {
-    return FingerTree.mkTree(measured(m, f)).empty();
-  }
-
-  /**
-   * Returns a finger tree which combines the integer node annotations with the
-   * maximum function.  A priority queue with integer priorities.
-   */
-  public static <A> FingerTree<Integer, P2<Integer, A>> emptyIntMax() {
-    return empty(intMaxMonoid, (P2<Integer, A> p) -> p._1());
-  }
-
-  public abstract Stream<A> toStream();
-
-}
+package fj.data.fingertrees;
+
+import fj.*;
+import fj.data.Option;
+import fj.data.Seq;
+import fj.data.Stream;
+
+import static fj.Monoid.intAdditionMonoid;
+import static fj.Monoid.intMaxMonoid;
+import static fj.data.Stream.nil;
+
+/**
+ * Provides 2-3 finger trees, a functional representation of persistent sequences supporting access to the ends in
+ * amortized O(1) time. Concatenation and splitting time is O(log n) in the size of the smaller piece.
+ * A general purpose data structure that can serve as a sequence, priority queue, search tree, priority search queue
+ * and more.
+ * <p/>
+ * This class serves as a datastructure construction kit, rather than a datastructure in its own right. By supplying
+ * a monoid, a measurement function, insertion, deletion, and so forth, any purely functional datastructure can be
+ * emulated. See {@link Seq} for an example.
+ * <p/>
+ * Based on "Finger trees: a simple general-purpose data structure", by Ralf Hinze and Ross Paterson.
+ *
+ * @param <V> The monoidal type with which to annotate nodes.
+ * @param <A> The type of the tree's elements.
+ */
+public abstract class FingerTree<V, A> {
+  private final Measured<V, A> m;
+
+  /**
+   * Folds the tree to the right with the given function and the given initial element.
+   *
+   * @param f A function with which to fold the tree.
+   * @param z An initial element to apply to the fold.
+   * @return A reduction of this tree by applying the given function, associating to the right.
+   */
+  public abstract <B> B foldRight(final F<A, F<B, B>> f, final B z);
+
+    public final <B> B foldRight(final F2<A, B, B> f, final B z) {
+        return foldRight(f.curry(), z);
+    }
+
+  /**
+   * Folds the tree to the right with the given function.
+   *
+   * @param f A function with which to fold the tree.
+   * @return A reduction of this tree by applying the given function, associating to the right.
+   */
+  public abstract A reduceRight(final F<A, F<A, A>> f);
+
+  /**
+   * Folds the tree to the left with the given function and the given initial element.
+   *
+   * @param f A function with which to fold the tree.
+   * @param z An initial element to apply to the fold.
+   * @return A reduction of this tree by applying the given function, associating to the left.
+   */
+  public abstract <B> B foldLeft(final F<B, F<A, B>> f, final B z);
+
+    public final <B> B foldLeft(final F2<B, A, B> f, final B z) {
+        return foldLeft(f.curry(), z);
+    }
+
+  /**
+   * Folds the tree to the left with the given function.
+   *
+   * @param f A function with which to fold the tree.
+   * @return A reduction of this tree by applying the given function, associating to the right.
+   */
+  public abstract A reduceLeft(final F<A, F<A, A>> f);
+
+  /**
+   * Maps the given function across this tree, measuring with the given Measured instance.
+   *
+   * @param f A function to map across the values of this tree.
+   * @param m A measuring with which to annotate the tree.
+   * @return A new tree with the same structure as this tree, with each element transformed by the given function,
+   *         and nodes annotated according to the given measuring.
+   */
+  public abstract <B> FingerTree<V, B> map(final F<A, B> f, final Measured<V, B> m);
+
+    public final <B> FingerTree<V, A> filter(final F<A, Boolean> f) {
+        FingerTree<V, A> tree = new Empty<>(m);
+        return foldLeft((acc, a) -> f.f(a) ? acc.snoc(a) : acc, tree);
+    }
+
+  /**
+   * Returns the sum of this tree's annotations.
+   *
+   * @return the sum of this tree's annotations.
+   */
+  public abstract V measure();
+
+  /**
+   * Indicates whether this tree is empty.
+   *
+   * @return true if this tree is the empty tree, otherwise false.
+   */
+  public final boolean isEmpty() {
+    return this instanceof Empty;
+  }
+  
+  public final Measured<V, A> measured() {
+    return m;
+  }
+
+  /**
+   * Provides pattern matching on trees. This is the Church encoding of the FingerTree datatype.
+   *
+   * @param empty  The function to apply to this empty tree.
+   * @param single A function to apply if this tree contains a single element.
+   * @param deep   A function to apply if this tree contains more than one element.
+   * @return The result of the function that matches this tree structurally, applied to this tree.
+   */
+  public abstract <B> B match(final F<Empty<V, A>, B> empty, final F<Single<V, A>, B> single,
+                              final F<Deep<V, A>, B> deep);
+
+  FingerTree(final Measured<V, A> m) {
+    this.m = m;
+  }
+
+  /**
+   * Constructs a Measured instance for the element type, given a monoid and a measuring function.
+   *
+   * @param monoid  A monoid for the measures.
+   * @param measure A function with which to measure element values.
+   * @return A Measured instance for the given element type, that uses the given monoid and measuring function.
+   */
+  public static <V, A> Measured<V, A> measured(final Monoid<V> monoid, final F<A, V> measure) {
+    return Measured.measured(monoid, measure);
+  }
+
+  /**
+   * Returns a builder of trees and tree components that annotates them using the given Measured instance.
+   *
+   * @param m A Measured instance with which to annotate trees, digits, and nodes.
+   * @return A builder of trees and tree components that annotates them using the given Measured instance.
+   */
+  public static <V, A> MakeTree<V, A> mkTree(final Measured<V, A> m) {
+    return new MakeTree<>(m);
+  }
+
+  /**
+   * Adds the given element to this tree as the first element.
+   *
+   * @param a The element to add to the front of this tree.
+   * @return A new tree with the given element at the front.
+   */
+  public abstract FingerTree<V, A> cons(final A a);
+
+  /**
+   * Adds the given element to this tree as the last element.
+   *
+   * @param a The element to add to the end of this tree.
+   * @return A new tree with the given element at the end.
+   */
+  public abstract FingerTree<V, A> snoc(final A a);
+
+  /**
+   * The first element of this tree. This is an O(1) operation.
+   *
+   * @return The first element if this tree is nonempty, otherwise throws an error.
+   */
+  public abstract A head();
+
+  public final Option<A> headOption() {
+      return isEmpty() ? Option.none() : Option.some(head());
+  }
+
+  /**
+   * Performs a reduction on this finger tree using the given arguments.
+   *
+   * @param nil  The value to return if this finger tree is empty.
+   * @param cons The function to apply to the head and tail of this finger tree  if it is not empty.
+   * @return A reduction on this finger tree.
+   */
+  public final <B> B uncons(B nil, F2<A, FingerTree<V, A>, B> cons) {
+    return isEmpty() ? nil : cons.f(head(), tail());
+  }
+
+
+  /**
+   * The last element of this tree. This is an O(1) operation.
+   *
+   * @return The last element if this tree is nonempty, otherwise throws an error.
+   */
+  public abstract A last();
+
+  /**
+   * The tree without the first element. This is an O(1) operation.
+   *
+   * @return The tree without the first element if this tree is nonempty, otherwise throws an error.
+   */
+  public abstract FingerTree<V, A> tail();
+
+  /**
+   * The tree without the last element. This is an O(1) operation.
+   *
+   * @return The tree without the last element if this tree is nonempty, otherwise throws an error.
+   */
+  public abstract FingerTree<V, A> init();
+
+  /**
+   * Appends one finger tree to another.
+   *
+   * @param t A finger tree to append to this one.
+   * @return A new finger tree which is a concatenation of this tree and the given tree.
+   */
+  public abstract FingerTree<V, A> append(final FingerTree<V, A> t);
+
+  /**
+   * Splits this tree into a pair of subtrees at the point where the given predicate, based on the measure,
+   * changes from <code>false</code> to <code>true</code>. This is a O(log(n)) operation.
+   *
+   * @return Pair: the subtree containing elements before the point where <code>pred</code> first holds and the subtree
+   *   containing element at and after the point where <code>pred</code> first holds. Empty if <code>pred</code> never holds.
+   */
+  public final P2<FingerTree<V, A>, FingerTree<V, A>> split(final F<V, Boolean> predicate) {
+    if (!isEmpty() && predicate.f(measure())) {
+      final P3<FingerTree<V, A>, A, FingerTree<V, A>> lxr = split1(predicate);
+      return P.p(lxr._1(), lxr._3().cons(lxr._2()));
+    } else {
+      return P.p(this, mkTree(m).empty());
+    }
+  }
+
+  /**
+   * Like <code>split</code>, but returns the element where <code>pred</code> first holds separately.
+   *
+   * Throws an error if the tree is empty.
+   */
+  public final P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate) {
+    return split1(predicate, measured().zero());
+  }
+
+  abstract P3<FingerTree<V, A>, A, FingerTree<V, A>> split1(final F<V, Boolean> predicate, final V acc);
+
+  public abstract P2<Integer, A> lookup(final F<V, Integer> o, final int i);
+
+    public abstract int length();
+
+    public static <A> FingerTree<Integer, A> emptyIntAddition() {
+      return empty(intAdditionMonoid, Function.constant(1));
+    }
+
+  /**
+   * Creates an empty finger tree with elements of type A and node annotations
+   * of type V.
+   *
+   * @param m A monoid to combine node annotations
+   * @param f Function to convert node element to annotation.
+   * @return An empty finger tree.
+   */
+  public static <V, A> FingerTree<V, A> empty(Monoid<V> m, F<A, V> f) {
+    return FingerTree.mkTree(measured(m, f)).empty();
+  }
+
+  /**
+   * Returns a finger tree which combines the integer node annotations with the
+   * maximum function.  A priority queue with integer priorities.
+   */
+  public static <A> FingerTree<Integer, P2<Integer, A>> emptyIntMax() {
+    return empty(intMaxMonoid, (P2<Integer, A> p) -> p._1());
+  }
+
+  public abstract Stream<A> toStream();
+
+}
diff --git a/core/src/test/java/fj/FFunctionsTest.java b/core/src/test/java/fj/FFunctionsTest.java
index e13b1f2b..e0df9164 100644
--- a/core/src/test/java/fj/FFunctionsTest.java
+++ b/core/src/test/java/fj/FFunctionsTest.java
@@ -1,43 +1,47 @@
-package fj;
-
-import fj.data.Tree;
-import fj.data.TreeZipper;
-import org.junit.Test;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
-
-public class FFunctionsTest {
-    @Test
-    public void testApply() {
-        F8<Integer, Integer, Integer, Integer,
-                Integer, Integer, Integer, Integer, Integer> f8 =
-                (i1, i2, i3, i4, i5, i6, i7, i8) ->
-                        i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
-        F7<Integer, Integer, Integer, Integer,
-                Integer, Integer, Integer, Integer> f7 = F8Functions.f(f8, 8);
-        F6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> f6 =
-                F7Functions.f(f7, 7);
-        F5<Integer, Integer, Integer, Integer, Integer, Integer> f5 = F6Functions.f(f6, 6);
-        F4<Integer, Integer, Integer, Integer, Integer> f4 = F5Functions.f(f5, 5);
-        F3<Integer, Integer, Integer, Integer> f3 = F4Functions.f(f4, 4);
-        F2<Integer, Integer, Integer> f2 = F3Functions.f(f3, 3);
-        F<Integer, Integer> f1 = F2Functions.f(f2, 2);
-        assertThat(F1Functions.f(f1, 1).f(), is(36));
-    }
-
-    @Test
-    public void testTreeK() {
-        final Tree<Integer> t1 = F1Functions.<Integer, Integer>treeK(Function.identity()).f(1);
-        final Tree<Integer> t2 = F1Functions.<Integer, Integer>treeK(Function.identity()).f(2);
-        assertThat(F1Functions.<Integer, Integer>mapTree(i -> i + 1).f(t1),
-                is(F1Functions.<Integer, Integer>mapTree(i -> i * 1).f(t2)));
-    }
-
-    @Test
-    public void testTreeZipperK() {
-        final TreeZipper<Integer> tz1 = F1Functions.<Integer, Integer>treeZipperK(Function.identity()).f(1);
-        final TreeZipper<Integer> tz2 = F1Functions.<Integer, Integer>treeZipperK(Function.identity()).f(2);
-        assertThat(F1Functions.<Integer, Integer>mapTreeZipper(i -> i + 1).f(tz1),
-                is(F1Functions.<Integer, Integer>mapTreeZipper(i -> i * 1).f(tz2)));
-    }
-}
+package fj;
+
+import fj.data.Tree;
+import fj.data.TreeZipper;
+import org.junit.Test;
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.*;
+
+public class FFunctionsTest {
+    @Test
+    public void testApply() {
+        F8<Integer, Integer, Integer, Integer,
+                Integer, Integer, Integer, Integer, Integer> f8 =
+                (i1, i2, i3, i4, i5, i6, i7, i8) ->
+                        i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
+        F7<Integer, Integer, Integer, Integer,
+                Integer, Integer, Integer, Integer> f7 = F8Functions.f(f8, 8);
+        F6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> f6 =
+                F7Functions.f(f7, 7);
+        F5<Integer, Integer, Integer, Integer, Integer, Integer> f5 = F6Functions.f(f6, 6);
+        F4<Integer, Integer, Integer, Integer, Integer> f4 = F5Functions.f(f5, 5);
+        F3<Integer, Integer, Integer, Integer> f3 = F4Functions.f(f4, 4);
+        F2<Integer, Integer, Integer> f2 = F3Functions.f(f3, 3);
+        F<Integer, Integer> f1 = f2.f(2);
+        assertThat(f1.f(1), is(36));
+    }
+
+    @Test
+    public void testTreeK() {
+        final Tree<Integer> t1 = Function.<Integer>identity().treeK().f(1);
+        final Tree<Integer> t2 = Function.<Integer>identity().treeK().f(2);
+        F<Integer, Integer> f = i -> i + 1;
+        F<Integer, Integer> g = i -> i * 1;
+        assertThat(f.mapTree().f(t1),
+                is(g.mapTree().f(t2)));
+    }
+
+    @Test
+    public void testTreeZipperK() {
+        final TreeZipper<Integer> tz1 = Function.<Integer>identity().treeZipperK().f(1);
+        final TreeZipper<Integer> tz2 = Function.<Integer>identity().treeZipperK().f(2);
+        F<Integer, Integer> f = i -> i + 1;
+        F<Integer, Integer> g = i -> i * 1;
+        assertThat(f.mapTreeZipper().f(tz1),
+                is(g.mapTreeZipper().f(tz2)));
+    }
+}
diff --git a/core/src/test/java/fj/FWFunctionsTest.java b/core/src/test/java/fj/FWFunctionsTest.java
deleted file mode 100644
index 1c034ab9..00000000
--- a/core/src/test/java/fj/FWFunctionsTest.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package fj;
-
-import org.junit.Test;
-
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
-
-public class FWFunctionsTest {
-    @Test
-    public void testLift1() {
-        F<Integer, Integer> f = i -> i + 1;
-        F1W<Integer, Integer> f1w = F1W.lift(f);
-        assertThat(f1w.f(1), is(2));
-    }
-
-    @Test
-    public void testLift2() {
-        F2<Integer, Integer, Integer> f2 = (i, j) -> i + j;
-        F2W<Integer, Integer, Integer> f2w = F2W.lift(f2);
-        assertThat(f2w.f(1, 2), is(3));
-    }
-
-}
diff --git a/core/src/test/java/fj/data/IOFunctionsTest.java b/core/src/test/java/fj/data/IOFunctionsTest.java
index 5213878c..adad0d11 100644
--- a/core/src/test/java/fj/data/IOFunctionsTest.java
+++ b/core/src/test/java/fj/data/IOFunctionsTest.java
@@ -107,7 +107,8 @@ public void testReplicateM() throws IOException {
   @Test
   public void testLift() throws IOException {
     final IO<String> readName = () -> new BufferedReader(new StringReader("foo")).readLine();
-    final F<String, IO<String>> upperCaseAndPrint = F1Functions.<String, IO<String>, String>o(this::println).f(String::toUpperCase);
+    F<String, IO<String>> f = this::println;
+    final F<String, IO<String>> upperCaseAndPrint = f.<String>o().f(String::toUpperCase);
     final IO<String> readAndPrintUpperCasedName = IOFunctions.bind(readName, upperCaseAndPrint);
     assertThat(readAndPrintUpperCasedName.run(), is("FOO"));
   }
diff --git a/core/src/test/java/fj/function/StringsTest.java b/core/src/test/java/fj/function/StringsTest.java
index 92cf44d3..c13e1b81 100644
--- a/core/src/test/java/fj/function/StringsTest.java
+++ b/core/src/test/java/fj/function/StringsTest.java
@@ -3,7 +3,6 @@
 import fj.Function;
 import org.junit.Test;
 
-import static fj.F1Functions.o;
 import static fj.Function.compose;
 import static fj.function.Strings.*;
 import static org.junit.Assert.*;
@@ -17,7 +16,7 @@ public void testLines() {
 
     @Test
     public void testLinesEmpty() {
-        assertThat(o(unlines(), lines()).f(""), is(""));
+        assertThat(unlines().o(lines()).f(""), is(""));
     }
 
     @Test
diff --git a/demo/src/main/java/fj/demo/Comonad_example.java b/demo/src/main/java/fj/demo/Comonad_example.java
index 8d5bc683..3b5661f8 100644
--- a/demo/src/main/java/fj/demo/Comonad_example.java
+++ b/demo/src/main/java/fj/demo/Comonad_example.java
@@ -1,6 +1,5 @@
 package fj.demo;
 
-import fj.F1Functions;
 import fj.P;
 import static fj.data.List.asString;
 import static fj.data.List.fromString;
@@ -26,7 +25,7 @@ public static Stream<Stream<Character>> perms(final Stream<Character> s) {
     for (final Zipper<Character> z : fromStream(s))
       r = join(z.cobind(zp ->
             perms(zp.lefts().reverse().append(zp.rights())).map(
-                F1Functions.o(Stream.<Character>cons().f(zp.focus()), P.p1())
+                    Stream.<Character>cons().f(zp.focus()).o(P.p1())
             )
       ).toStream());
     return r;
diff --git a/demo/src/main/java/fj/demo/IODemo.java b/demo/src/main/java/fj/demo/IODemo.java
index 6451a46b..ea313e77 100644
--- a/demo/src/main/java/fj/demo/IODemo.java
+++ b/demo/src/main/java/fj/demo/IODemo.java
@@ -4,7 +4,6 @@
 import fj.data.IOFunctions;
 import fj.data.LazyString;
 
-import static fj.F1W.lift;
 import static fj.data.IOFunctions.interact;
 import static fj.data.IOFunctions.runSafe;
 import static fj.data.LazyString.lines_;
@@ -29,7 +28,7 @@ public static void main(String[] args) {
      * and prints that last line.
      */
     public final void readFirstShortLine() {
-        F<LazyString, LazyString> f = lift(lines_()).andThen(l -> l.filter(s -> s.length() < 3)).andThen(unlines_());
+        F<LazyString, LazyString> f = lines_().andThen(l -> l.filter(s -> s.length() < 3)).andThen(unlines_());
         runSafe(interact(f));
     }
 
@@ -37,7 +36,7 @@ public final void readFirstShortLine() {
      * Read a stream of input lazily using interact, in effect reading the first line
      */
     public final void readFirstLine() {
-        F<LazyString, LazyString> f = lift(LazyString::lines).andThen(unlines_());
+        F<LazyString, LazyString> f = lines_().andThen(unlines_());
         runSafe(interact(f));
     }
 
diff --git a/demo/src/main/java/fj/demo/IOWalkthrough.java b/demo/src/main/java/fj/demo/IOWalkthrough.java
index 609d2502..5c1c4663 100644
--- a/demo/src/main/java/fj/demo/IOWalkthrough.java
+++ b/demo/src/main/java/fj/demo/IOWalkthrough.java
@@ -1,8 +1,6 @@
 package fj.demo;
 
 import fj.F;
-import fj.F1Functions;
-import fj.F1W;
 import fj.Unit;
 import fj.data.IO;
 import fj.data.IOFunctions;
@@ -49,7 +47,7 @@ public static void main(String[] args) {
 
         // now we create a function which takes a string, upper cases it and creates an IO value that would print the upper cased string if executed
 
-        final F<String, IO<Unit>> upperCaseAndPrint = F1Functions.<String, IO<Unit>, String>o(IOFunctions::stdoutPrintln).f(String::toUpperCase);
+        final F<String, IO<Unit>> upperCaseAndPrint = s -> stdoutPrintln(s.toUpperCase());
 
         // we now want to compose reading the name with printing it, for that we need to have access to the runtime value that is returned when the
         // IO value for read is executed, hence we use fj.data.IOFunctions.bind instead of fj.data.IOFunctions.append
@@ -73,10 +71,11 @@ public static void main(String[] args) {
         // assigning the functions to variables like above, but you can use the fj.F1W syntax wrapper for composing single-argument functions and fj.data.IOW
         // for composing IO values instead, the entire program can be written like so:
 
+        F<String, String> f = String::toUpperCase;
         IOW.lift(stdoutPrintln("What's your name again?"))
                 .append(stdoutPrint("Name: "))
                 .append(stdinReadLine())
-                .bind(F1W.lift((String s) -> s.toUpperCase()).andThen(IOFunctions::stdoutPrintln))
+                .bind(f.andThen(IOFunctions::stdoutPrintln))
                 .safe().run().on((IOException e) -> { e.printStackTrace(); return Unit.unit(); });
     }
 }
diff --git a/demo/src/main/java/fj/demo/Primes2.java b/demo/src/main/java/fj/demo/Primes2.java
index 96a852f3..37bfb249 100644
--- a/demo/src/main/java/fj/demo/Primes2.java
+++ b/demo/src/main/java/fj/demo/Primes2.java
@@ -1,7 +1,5 @@
 package fj.demo;
 
-import fj.F1Functions;
-
 import static fj.data.Enumerator.naturalEnumerator;
 
 import fj.Show;
@@ -21,7 +19,7 @@
 public class Primes2 {
   // Finds primes in a given stream.
   public static Stream<Natural> sieve(final Stream<Natural> xs) {
-    return cons(xs.head(), () -> sieve(xs.tail()._1().removeAll(F1Functions.o(naturalOrd.equal().eq(ZERO), mod.f(xs.head())))));
+    return cons(xs.head(), () -> sieve(xs.tail()._1().removeAll(naturalOrd.equal().eq(ZERO).o(mod.f(xs.head())))));
   }
 
   // A stream of all primes less than n.
diff --git a/demo/src/main/java/fj/demo/WriterDemo_Halver.java b/demo/src/main/java/fj/demo/WriterDemo_Halver.java
index a2a270f6..8473e588 100644
--- a/demo/src/main/java/fj/demo/WriterDemo_Halver.java
+++ b/demo/src/main/java/fj/demo/WriterDemo_Halver.java
@@ -4,7 +4,6 @@
 import fj.P2;
 import fj.data.Writer;
 
-import static fj.F1Functions.map;
 import static fj.Monoid.stringMonoid;
 
 /**
@@ -24,7 +23,7 @@ static void testWriter() {
         Integer init = 32;
         P2<String, Integer> p1 = half().f(init).flatMap(half()).flatMap(half()).run();
         System.out.println(p1);
-        System.out.println(map(half(), w -> w.flatMap(half()).flatMap(half()).run()).f(init));
+        System.out.println(half().map(w -> w.flatMap(half()).flatMap(half()).run()).f(init));
     }
 
 }
diff --git a/demo/src/main/java/fj/demo/concurrent/MapReduce.java b/demo/src/main/java/fj/demo/concurrent/MapReduce.java
index 3cb2d761..38a62caa 100644
--- a/demo/src/main/java/fj/demo/concurrent/MapReduce.java
+++ b/demo/src/main/java/fj/demo/concurrent/MapReduce.java
@@ -35,14 +35,15 @@ public static Promise<Long> countWords(final List<Stream<Character>> documents,
 
   // Main program does the requisite IO gymnastics
   public static void main(final String[] args) {
+      F<String, BufferedReader> z = fileName -> {
+          try {
+              return new BufferedReader(new FileReader(new File(fileName)));
+          } catch (FileNotFoundException e) {
+              throw new Error(e);
+          }
+      };
     final List<Stream<Character>> documents = list(args).map(
-        F1Functions.andThen(fileName -> {
-                try {
-                    return new BufferedReader(new FileReader(new File(fileName)));
-                } catch (FileNotFoundException e) {
-                    throw new Error(e);
-                }
-        }, new F<BufferedReader, Stream<Character>>() {
+        z.andThen(new F<BufferedReader, Stream<Character>>() {
             public Stream<Character> f(final BufferedReader reader) {
                 final Option<String> s;
                 try {
diff --git a/demo/src/main/java/fj/demo/euler/Problem2.java b/demo/src/main/java/fj/demo/euler/Problem2.java
index eda4a72d..a5639ab9 100644
--- a/demo/src/main/java/fj/demo/euler/Problem2.java
+++ b/demo/src/main/java/fj/demo/euler/Problem2.java
@@ -1,8 +1,6 @@
 package fj.demo.euler;
 
-import fj.F1Functions;
 import fj.F2;
-import fj.F2Functions;
 import fj.data.Stream;
 import static fj.data.Stream.cons;
 import static fj.function.Integers.even;
@@ -23,13 +21,13 @@ public static void main(final String[] args) {
 	static void java7() {
 		final Stream<Integer> fibs = new F2<Integer, Integer, Stream<Integer>>() {
 			public Stream<Integer> f(final Integer a, final Integer b) {
-				return cons(a, F1Functions.lazy(F2Functions.curry(this).f(b)).f(a + b));
+				return cons(a, this.curry().f(b).lazy().f(a + b));
 			}
 		}.f(1, 2);
 		out.println(sum(fibs.filter(even).takeWhile(intOrd.isLessThan(4000001)).toList()));
 	}
 
-	static F2<Integer, Integer, Stream<Integer>> fibsJava8 = (a, b) -> cons(a, F1Functions.lazy(F2Functions.curry(Problem2.fibsJava8).f(b)).f(a + b));
+	static F2<Integer, Integer, Stream<Integer>> fibsJava8 = (a, b) -> cons(a, Problem2.fibsJava8.curry().f(b).lazy().f(a + b));
 
 	static void java8() {
 		out.println(sum(fibsJava8.f(1, 2).filter(even).takeWhile(intOrd.isLessThan(4000001)).toList()));
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
index dd95dabf..dfde81e3 100755
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
@@ -1,119 +1,119 @@
-package fj
-package data
-
-import fj.function.Effect1
-import org.scalacheck.Prop._
-import ArbitraryHashMap._
-import Equal._
-import Hash._
-import Ord._
-import fj.data.Option._
-import scala.collection.JavaConversions._
-import org.scalacheck.{Arbitrary, Properties}
-import data.ArbitraryList._
-import org.scalacheck.Arbitrary._
-import java.util.Map
-
-object CheckHashMap extends Properties("HashMap") {
-  implicit val equalInt: Equal[Int] = intEqual contramap ((x: Int) => (x: java.lang.Integer))
-  implicit val hashInt: Hash[Int] = intHash contramap ((x: Int) => (x: java.lang.Integer))
-
-  implicit def arbitraryListOfIterableP2: Arbitrary[java.lang.Iterable[P2[Int, String]]] =
-    Arbitrary(listOf(arbitrary[(Int, String)])
-      .map(_.map((tuple: (Int, String)) => P.p(tuple._1, tuple._2))
-      .asInstanceOf[java.lang.Iterable[P2[Int, String]]]))
-
-  property("eq") = forAll((m: HashMap[Int, String], x: Int, y: Int) => m.eq(x, y) == equalInt.eq(x, y))
-
-  property("hash") = forAll((m: HashMap[Int, String], x: Int) => m.hash(x) == hashInt.hash(x))
-
-  property("get") = forAll((m: HashMap[Int, String], k: Int) => optionEqual(stringEqual).eq(m.get(k), m.get.f(k)))
-
-  property("set") = forAll((m: HashMap[Int, String], k: Int, v: String) => {
-    m.set(k, v)
-    m.get(k).some == v
-  })
-
-  property("clear") = forAll((m: HashMap[Int, String], k: Int) => {
-    m.clear
-    m.get(k).isNone
-  })
-
-  property("contains") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isSome == m.contains(k))
-
-  property("keys") = forAll((m: HashMap[Int, String]) => m.keys.forall((k: Int) => (m.get(k).isSome): java.lang.Boolean))
-
-  property("isEmpty") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isNone || !m.isEmpty)
-
-  property("size") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isNone || m.size != 0)
-
-  property("delete") = forAll((m: HashMap[Int, String], k: Int) => {
-    m.delete(k)
-    m.get(k).isNone
-  })
-
-  property("toList") = forAll((m: HashMap[Int, String]) => {
-    val list = m.toList
-    list.length() == m.keys().length() && list.forall((entry: P2[Int, String]) =>
-      optionEqual(stringEqual).eq(m.get(entry._1()), some(entry._2())).asInstanceOf[java.lang.Boolean])
-  })
-
-  property("getDelete") = forAll((m: HashMap[Int, String], k: Int) => {
-    val x = m.get(k)
-    val y = m.getDelete(k)
-    val z = m.get(k)
-
-    z.isNone && optionEqual(stringEqual).eq(x, y)
-  })
-
-  property("from") = forAll((entries: java.lang.Iterable[P2[Int, String]]) => {
-    val map = HashMap.iterableHashMap[Int, String](equalInt, hashInt, entries)
-    entries.groupBy(_._1)
-      .forall((e: (Int, Iterable[P2[Int, String]])) => e._2
-      .exists((elem: P2[Int, String]) => optionEqual(stringEqual).eq(map.get(e._1), Option.some(elem._2))))
-  })
-
-  property("map") = forAll((m: HashMap[Int, String]) => {
-    val keyFunction: F[Int, String] = (i: Int) => i.toString
-    val valueFunction: (String) => String = (s: String) => s + "a"
-    val mapped = m.map(keyFunction, valueFunction, stringEqual, stringHash)
-    val keysAreEqual = m.keys().map(keyFunction).toSet == mapped.keys.toSet
-    val appliedFunctionsToKeysAndValues: Boolean = m.keys().forall((key: Int) => {
-      val mappedValue = mapped.get(keyFunction.f(key))
-      val oldValueMapped = some(valueFunction.f(m.get(key).some()))
-      Equal.optionEqual(stringEqual).eq(mappedValue, oldValueMapped)
-    })
-
-    keysAreEqual && appliedFunctionsToKeysAndValues
-  })
-
-  property("toMap") = forAll((m: HashMap[Int, String]) => {
-    val toMap: Map[Int, String] = m.toMap
-    m.keys().forall((key: Int) => m.get(key).some() == toMap.get(key))
-  })
-
-  property("fromMap") = forAll((m: HashMap[Int, String]) => {
-    val map = new java.util.HashMap[Int, String]()
-    m.keys().foreach((key: Int) => {
-      map.put(key, m.get(key).some())
-      Unit.unit()
-    })
-    val fromMap: HashMap[Int, String] = new HashMap[Int, String](map)
-    val keysAreEqual = m.keys.toSet == fromMap.keys.toSet
-    val valuesAreEqual = m.keys().forall((key: Int) =>
-      optionEqual(stringEqual).eq(m.get(key), fromMap.get(key)))
-    keysAreEqual && valuesAreEqual
-  })
-
-  property("No null values") = forAll((m: List[Int]) => {
-    val map = HashMap.hashMap[Int, Int]()
-    m.foreachDoEffect(new Effect1[Int] {
-      def f(a: Int) {
-        map.set(a, null.asInstanceOf[Int])
-      }
-    })
-    m.forall(new F[Int, java.lang.Boolean]() {
-      def f(a: Int) = map.contains(a) == false
-    })
-  })
+package fj
+package data
+
+import fj.function.Effect1
+import org.scalacheck.Prop._
+import ArbitraryHashMap._
+import Equal._
+import Hash._
+import Ord._
+import fj.data.Option._
+import scala.collection.JavaConversions._
+import org.scalacheck.{Arbitrary, Properties}
+import data.ArbitraryList._
+import org.scalacheck.Arbitrary._
+import java.util.Map
+
+object CheckHashMap extends Properties("HashMap") {
+  implicit val equalInt: Equal[Int] = intEqual contramap ((x: Int) => (x: java.lang.Integer))
+  implicit val hashInt: Hash[Int] = intHash contramap ((x: Int) => (x: java.lang.Integer))
+
+  implicit def arbitraryListOfIterableP2: Arbitrary[java.lang.Iterable[P2[Int, String]]] =
+    Arbitrary(listOf(arbitrary[(Int, String)])
+      .map(_.map((tuple: (Int, String)) => P.p(tuple._1, tuple._2))
+      .asInstanceOf[java.lang.Iterable[P2[Int, String]]]))
+
+  property("eq") = forAll((m: HashMap[Int, String], x: Int, y: Int) => m.eq(x, y) == equalInt.eq(x, y))
+
+  property("hash") = forAll((m: HashMap[Int, String], x: Int) => m.hash(x) == hashInt.hash(x))
+
+  property("get") = forAll((m: HashMap[Int, String], k: Int) => optionEqual(stringEqual).eq(m.get(k), m.get.f(k)))
+
+  property("set") = forAll((m: HashMap[Int, String], k: Int, v: String) => {
+    m.set(k, v)
+    m.get(k).some == v
+  })
+
+  property("clear") = forAll((m: HashMap[Int, String], k: Int) => {
+    m.clear
+    m.get(k).isNone
+  })
+
+  property("contains") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isSome == m.contains(k))
+
+  property("keys") = forAll((m: HashMap[Int, String]) => m.keys.forall((k: Int) => (m.get(k).isSome): java.lang.Boolean))
+
+  property("isEmpty") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isNone || !m.isEmpty)
+
+  property("size") = forAll((m: HashMap[Int, String], k: Int) => m.get(k).isNone || m.size != 0)
+
+  property("delete") = forAll((m: HashMap[Int, String], k: Int) => {
+    m.delete(k)
+    m.get(k).isNone
+  })
+
+  property("toList") = forAll((m: HashMap[Int, String]) => {
+    val list = m.toList
+    list.length() == m.keys().length() && list.forall((entry: P2[Int, String]) =>
+      optionEqual(stringEqual).eq(m.get(entry._1()), some(entry._2())).asInstanceOf[java.lang.Boolean])
+  })
+
+  property("getDelete") = forAll((m: HashMap[Int, String], k: Int) => {
+    val x = m.get(k)
+    val y = m.getDelete(k)
+    val z = m.get(k)
+
+    z.isNone && optionEqual(stringEqual).eq(x, y)
+  })
+
+  property("from") = forAll((entries: java.lang.Iterable[P2[Int, String]]) => {
+    val map = HashMap.iterableHashMap[Int, String](equalInt, hashInt, entries)
+    entries.groupBy(_._1)
+      .forall((e: (Int, Iterable[P2[Int, String]])) => e._2
+      .exists((elem: P2[Int, String]) => optionEqual(stringEqual).eq(map.get(e._1), Option.some(elem._2))))
+  })
+
+  property("map") = forAll((m: HashMap[Int, String]) => {
+    val keyFunction: F[Int, String] = (i: Int) => i.toString
+    val valueFunction: (String) => String = (s: String) => s + "a"
+    val mapped = m.map(keyFunction, valueFunction, stringEqual, stringHash)
+    val keysAreEqual = m.keys().map(keyFunction).toSet == mapped.keys.toSet
+    val appliedFunctionsToKeysAndValues: Boolean = m.keys().forall((key: Int) => {
+      val mappedValue = mapped.get(keyFunction.f(key))
+      val oldValueMapped = some(valueFunction.f(m.get(key).some()))
+      Equal.optionEqual(stringEqual).eq(mappedValue, oldValueMapped)
+    })
+
+    keysAreEqual && appliedFunctionsToKeysAndValues
+  })
+
+  property("toMap") = forAll((m: HashMap[Int, String]) => {
+    val toMap: Map[Int, String] = m.toMap
+    m.keys().forall((key: Int) => m.get(key).some() == toMap.get(key))
+  })
+
+  property("fromMap") = forAll((m: HashMap[Int, String]) => {
+    val map = new java.util.HashMap[Int, String]()
+    m.keys().foreach((key: Int) => {
+      map.put(key, m.get(key).some())
+      Unit.unit()
+    })
+    val fromMap: HashMap[Int, String] = new HashMap[Int, String](map)
+    val keysAreEqual = m.keys.toSet == fromMap.keys.toSet
+    val valuesAreEqual = m.keys().forall((key: Int) =>
+      optionEqual(stringEqual).eq(m.get(key), fromMap.get(key)))
+    keysAreEqual && valuesAreEqual
+  })
+
+  property("No null values") = forAll((list: List[Int]) => {
+    val m = HashMap.hashMap[Int, Int]()
+    list.foreachDoEffect(new Effect1[Int] {
+      def f(a: Int) {
+        m.set(a, null.asInstanceOf[Int])
+      }
+    })
+    list.forall(new F[Int, java.lang.Boolean]() {
+      def f(a: Int) = m.contains(a) == false
+    })
+  })
 }
\ No newline at end of file
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckIteratee.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckIteratee.scala
index 86feeb7a..ff085f87 100644
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckIteratee.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckIteratee.scala
@@ -7,7 +7,6 @@ import Unit.unit
 import List.{list, nil}
 import Option.{some, none}
 import fj.Function._
-import fj.F1Functions
 import fj.data.Iteratee._
 
 import org.scalacheck.Prop._
@@ -50,7 +49,7 @@ object CheckIteratee extends Properties("Iteratee") {
       var tail = l
       while(!isDone(i) && !tail.isEmpty) {
         val input = Input.el(tail.head)
-        val cont: F[F[Input[E], IterV[E, A]], P1[IterV[E, A]]] = F1Functions.`lazy`(Function.apply(input))
+        val cont: F[F[Input[E], IterV[E, A]], P1[IterV[E, A]]] = Function.apply(input).`lazy`()
         i = i.fold(done, cont)._1
         tail = tail.tail
       }
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 87e2b52a..044595d0 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -5,8 +5,6 @@
 import fj.test.*;
 import org.junit.Test;
 
-import static fj.F1Functions.bind;
-import static fj.F1Functions.map;
 import static fj.test.Arbitrary.*;
 import static fj.test.Cogen.cogenInteger;
 import static fj.test.Property.prop;
@@ -44,7 +42,7 @@ public void testMapProp() {
                 arbF(cogenInteger, arbInteger),
                 arbInteger,
                 (f, g, i) -> {
-                    int expected = map(f, g).f(i);
+                    int expected = f.map(g).f(i);
 //                    System.out.println(String.format("input: %d, result: %d", i, expected));
                     return prop(expected == Reader.unit(f).map(g).f(i));
                 });
@@ -59,7 +57,7 @@ public void testFlatMapProp() {
                 a,
                 arbInteger,
                 (f, g, i) -> {
-                    int expected = bind(f, j -> g.f(j).getFunction()).f(i);
+                    int expected = f.bind(j -> g.f(j).getFunction()).f(i);
 //              System.out.println(String.format("input: %d, result: %d", i, expected));
                     return prop(expected == Reader.unit(f).flatMap(g).f(i));
                 }

From 2f005d9ff90641085e7678f9199a171177813af8 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 2 Apr 2021 00:27:14 +1000
Subject: [PATCH 290/336] Removed FxFunctions and FxW for arity 3-8

---
 core/src/main/java/fj/F3Functions.java    | 22 ----------------------
 core/src/main/java/fj/F3W.java            |  8 --------
 core/src/main/java/fj/F4Functions.java    | 21 ---------------------
 core/src/main/java/fj/F4W.java            |  9 ---------
 core/src/main/java/fj/F5Functions.java    | 21 ---------------------
 core/src/main/java/fj/F5W.java            |  9 ---------
 core/src/main/java/fj/F6Functions.java    | 22 ----------------------
 core/src/main/java/fj/F6W.java            |  9 ---------
 core/src/main/java/fj/F7Functions.java    | 22 ----------------------
 core/src/main/java/fj/F7W.java            |  9 ---------
 core/src/main/java/fj/F8Functions.java    | 20 --------------------
 core/src/main/java/fj/F8W.java            |  9 ---------
 core/src/test/java/fj/FFunctionsTest.java | 17 -----------------
 13 files changed, 198 deletions(-)
 delete mode 100644 core/src/main/java/fj/F3Functions.java
 delete mode 100644 core/src/main/java/fj/F3W.java
 delete mode 100644 core/src/main/java/fj/F4Functions.java
 delete mode 100644 core/src/main/java/fj/F4W.java
 delete mode 100644 core/src/main/java/fj/F5Functions.java
 delete mode 100644 core/src/main/java/fj/F5W.java
 delete mode 100644 core/src/main/java/fj/F6Functions.java
 delete mode 100644 core/src/main/java/fj/F6W.java
 delete mode 100644 core/src/main/java/fj/F7Functions.java
 delete mode 100644 core/src/main/java/fj/F7W.java
 delete mode 100644 core/src/main/java/fj/F8Functions.java
 delete mode 100644 core/src/main/java/fj/F8W.java

diff --git a/core/src/main/java/fj/F3Functions.java b/core/src/main/java/fj/F3Functions.java
deleted file mode 100644
index 18e811d9..00000000
--- a/core/src/main/java/fj/F3Functions.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F3Functions {
-
-
-  private F3Functions() {
-  }
-
-  /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument.
-     */
-  public static <A, B, C, D> F2<B, C, D> f(final F3<A, B, C, D> f, final A a) {
-        return (b, c) -> f.f(a, b, c);
-    }
-
-}
diff --git a/core/src/main/java/fj/F3W.java b/core/src/main/java/fj/F3W.java
deleted file mode 100644
index d6ffa80b..00000000
--- a/core/src/main/java/fj/F3W.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F3W<A, B, C, D> implements F3<A, B, C, D> {
-
-}
diff --git a/core/src/main/java/fj/F4Functions.java b/core/src/main/java/fj/F4Functions.java
deleted file mode 100644
index cb353764..00000000
--- a/core/src/main/java/fj/F4Functions.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F4Functions {
-
-  private F4Functions() {
-  }
-
-  /**
-     * Partial application.
-     *
-     * @param a The <code>A</code> to which to apply this function.
-     * @return The function partially applied to the given argument.
-     */
-  public static <A, B, C, D, E> F3<B, C, D, E> f(final F4<A, B, C, D, E> f, final A a) {
-        return (b, c, d) -> f.f(a, b, c, d);
-    }
-
-}
diff --git a/core/src/main/java/fj/F4W.java b/core/src/main/java/fj/F4W.java
deleted file mode 100644
index 3cc92e55..00000000
--- a/core/src/main/java/fj/F4W.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F4W<A, B, C, D, E> implements F4<A, B, C, D, E> {
-
-
-}
diff --git a/core/src/main/java/fj/F5Functions.java b/core/src/main/java/fj/F5Functions.java
deleted file mode 100644
index c39b228f..00000000
--- a/core/src/main/java/fj/F5Functions.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F5Functions {
-
-	private F5Functions() {
-	}
-
-	/**
-	 * Partial application.
-	 *
-	 * @param a The <code>A</code> to which to apply this function.
-	 * @return The function partially applied to the given argument.
-	 */
-	public static <A, B, C, D, E, F$> F4<B, C, D, E, F$> f(final F5<A, B, C, D, E, F$> f, final A a) {
-		return (b, c, d, e) -> f.f(a, b, c, d, e);
-	}
-
-}
diff --git a/core/src/main/java/fj/F5W.java b/core/src/main/java/fj/F5W.java
deleted file mode 100644
index 5fa407cd..00000000
--- a/core/src/main/java/fj/F5W.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F5W<A, B, C, D, E, $F> implements F5<A, B, C, D, E, $F> {
-
-
-}
diff --git a/core/src/main/java/fj/F6Functions.java b/core/src/main/java/fj/F6Functions.java
deleted file mode 100644
index 320b95f4..00000000
--- a/core/src/main/java/fj/F6Functions.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F6Functions {
-
-	private F6Functions() {
-	}
-
-	/**
-	 * Partial application.
-	 *
-	 * @param a The <code>A</code> to which to apply this function.
-	 * @return The function partially applied to the given argument.
-	 */
-	public static <A, B, C, D, E, F$, G> F5<B, C, D, E, F$, G> f(final F6<A, B, C, D, E, F$, G> func, final A a) {
-		return (b, c, d, e, f) -> func.f(a, b, c, d, e, f);
-	}
-
-
-}
diff --git a/core/src/main/java/fj/F6W.java b/core/src/main/java/fj/F6W.java
deleted file mode 100644
index adaf723f..00000000
--- a/core/src/main/java/fj/F6W.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F6W<A, B, C, D, E, $F, G> implements F6<A, B, C, D, E, $F, G> {
-
-
-}
diff --git a/core/src/main/java/fj/F7Functions.java b/core/src/main/java/fj/F7Functions.java
deleted file mode 100644
index e583ba4b..00000000
--- a/core/src/main/java/fj/F7Functions.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F7Functions {
-
-	private F7Functions() {
-	}
-
-	/**
-	 * Partial application.
-	 *
-	 * @param a The <code>A</code> to which to apply this function.
-	 * @return The function partially applied to the given argument.
-	 */
-	public static <A, B, C, D, E, F$, G, H> F6<B, C, D, E, F$, G, H> f(final F7<A, B, C, D, E, F$, G, H> func, final A a) {
-		return (b, c, d, e, f, g) -> func.f(a, b, c, d, e, f, g);
-	}
-
-
-}
diff --git a/core/src/main/java/fj/F7W.java b/core/src/main/java/fj/F7W.java
deleted file mode 100644
index fdcec3d5..00000000
--- a/core/src/main/java/fj/F7W.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F7W<A, B, C, D, E, $F, G, H> implements F7<A, B, C, D, E, $F, G, H> {
-
-
-}
diff --git a/core/src/main/java/fj/F8Functions.java b/core/src/main/java/fj/F8Functions.java
deleted file mode 100644
index 8b9883a3..00000000
--- a/core/src/main/java/fj/F8Functions.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 6/04/2014.
- */
-public final class F8Functions {
-
-	private F8Functions() {
-	}
-
-	/**
-	 * Partial application.
-	 *
-	 * @return The function partially applied to the given argument.
-	 */
-	public static <A, B, C, D, E, F$, G, H, I> F7<B, C, D, E, F$, G, H, I> f(final F8<A, B, C, D, E, F$, G, H, I> func, final A a) {
-		return (b, c, d, e, f, g, h) -> func.f(a, b, c, d, e, f, g, h);
-	}
-
-}
diff --git a/core/src/main/java/fj/F8W.java b/core/src/main/java/fj/F8W.java
deleted file mode 100644
index d0a9f861..00000000
--- a/core/src/main/java/fj/F8W.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package fj;
-
-/**
- * Created by MarkPerry on 22/01/2015.
- */
-public abstract class F8W<A, B, C, D, E, $F, G, H, I> implements F8<A, B, C, D, E, $F, G, H, I> {
-
-
-}
diff --git a/core/src/test/java/fj/FFunctionsTest.java b/core/src/test/java/fj/FFunctionsTest.java
index e0df9164..b235ff67 100644
--- a/core/src/test/java/fj/FFunctionsTest.java
+++ b/core/src/test/java/fj/FFunctionsTest.java
@@ -7,23 +7,6 @@
 import static org.junit.Assert.*;
 
 public class FFunctionsTest {
-    @Test
-    public void testApply() {
-        F8<Integer, Integer, Integer, Integer,
-                Integer, Integer, Integer, Integer, Integer> f8 =
-                (i1, i2, i3, i4, i5, i6, i7, i8) ->
-                        i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
-        F7<Integer, Integer, Integer, Integer,
-                Integer, Integer, Integer, Integer> f7 = F8Functions.f(f8, 8);
-        F6<Integer, Integer, Integer, Integer, Integer, Integer, Integer> f6 =
-                F7Functions.f(f7, 7);
-        F5<Integer, Integer, Integer, Integer, Integer, Integer> f5 = F6Functions.f(f6, 6);
-        F4<Integer, Integer, Integer, Integer, Integer> f4 = F5Functions.f(f5, 5);
-        F3<Integer, Integer, Integer, Integer> f3 = F4Functions.f(f4, 4);
-        F2<Integer, Integer, Integer> f2 = F3Functions.f(f3, 3);
-        F<Integer, Integer> f1 = f2.f(2);
-        assertThat(f1.f(1), is(36));
-    }
 
     @Test
     public void testTreeK() {

From 202f88c5eb051fe74cfff9ff71952058f47d936a Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 2 Apr 2021 00:31:15 +1000
Subject: [PATCH 291/336] Added functional interface annotations to functions

---
 core/src/main/java/fj/F.java  | 1 +
 core/src/main/java/fj/F0.java | 1 +
 core/src/main/java/fj/F2.java | 1 +
 core/src/main/java/fj/F3.java | 1 +
 core/src/main/java/fj/F4.java | 1 +
 core/src/main/java/fj/F5.java | 1 +
 core/src/main/java/fj/F6.java | 1 +
 core/src/main/java/fj/F7.java | 1 +
 core/src/main/java/fj/F8.java | 1 +
 9 files changed, 9 insertions(+)

diff --git a/core/src/main/java/fj/F.java b/core/src/main/java/fj/F.java
index d2208236..45cec4fe 100644
--- a/core/src/main/java/fj/F.java
+++ b/core/src/main/java/fj/F.java
@@ -21,6 +21,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F<A, B> extends Function<A, B> {
   /**
    * Transform <code>A</code> to <code>B</code>.
diff --git a/core/src/main/java/fj/F0.java b/core/src/main/java/fj/F0.java
index eab82a01..14c00ca2 100644
--- a/core/src/main/java/fj/F0.java
+++ b/core/src/main/java/fj/F0.java
@@ -3,6 +3,7 @@
 /**
  * Created by MarkPerry on 21/01/2015.
  */
+@FunctionalInterface
 public interface F0<A> {
 
     A f();
diff --git a/core/src/main/java/fj/F2.java b/core/src/main/java/fj/F2.java
index ba0e6f2f..4f7c306d 100644
--- a/core/src/main/java/fj/F2.java
+++ b/core/src/main/java/fj/F2.java
@@ -18,6 +18,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F2<A, B, C> extends BiFunction<A, B, C> {
   /**
    * Transform <code>A</code> and <code>B</code> to <code>C</code>.
diff --git a/core/src/main/java/fj/F3.java b/core/src/main/java/fj/F3.java
index 540afdaa..b8c4dcf3 100644
--- a/core/src/main/java/fj/F3.java
+++ b/core/src/main/java/fj/F3.java
@@ -6,6 +6,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F3<A, B, C, D> {
   /**
    * Transform <code>A</code>, <code>B</code> and <code>C</code> to <code>D</code>.
diff --git a/core/src/main/java/fj/F4.java b/core/src/main/java/fj/F4.java
index 84dcfafa..d63f03a7 100644
--- a/core/src/main/java/fj/F4.java
+++ b/core/src/main/java/fj/F4.java
@@ -6,6 +6,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F4<A, B, C, D, E> {
   /**
    * Transform <code>A</code>, <code>B</code>, <code>C</code> and <code>D</code> to <code>E</code>.
diff --git a/core/src/main/java/fj/F5.java b/core/src/main/java/fj/F5.java
index 5fea676b..f63ae797 100644
--- a/core/src/main/java/fj/F5.java
+++ b/core/src/main/java/fj/F5.java
@@ -7,6 +7,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F5<A, B, C, D, E, F$> {
   /**
    * Transform <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code> and <code>E</code> to
diff --git a/core/src/main/java/fj/F6.java b/core/src/main/java/fj/F6.java
index 20101cf7..558c17fc 100644
--- a/core/src/main/java/fj/F6.java
+++ b/core/src/main/java/fj/F6.java
@@ -7,6 +7,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F6<A, B, C, D, E, F$, G> {
   /**
    * Transform <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code>, <code>E</code> and
diff --git a/core/src/main/java/fj/F7.java b/core/src/main/java/fj/F7.java
index 5a3ea1ef..05caefb4 100644
--- a/core/src/main/java/fj/F7.java
+++ b/core/src/main/java/fj/F7.java
@@ -7,6 +7,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F7<A, B, C, D, E, F$, G, H> {
   /**
    * Transform <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code>, <code>E</code>,
diff --git a/core/src/main/java/fj/F8.java b/core/src/main/java/fj/F8.java
index 8b986456..5aa103f2 100644
--- a/core/src/main/java/fj/F8.java
+++ b/core/src/main/java/fj/F8.java
@@ -7,6 +7,7 @@
  *
  * @version %build.number%
  */
+@FunctionalInterface
 public interface F8<A, B, C, D, E, F$, G, H, I> {
   /**
    * Transform <code>A</code>, <code>B</code>, <code>C</code>, <code>D</code>, <code>E</code>,

From 2ee2950ab391a7213b01d9e0f6a81473e8b4c76e Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 2 Apr 2021 01:37:55 +1000
Subject: [PATCH 292/336] Removed IOW

---
 core/src/main/java/fj/data/IO.java            | 28 ++++++++++++
 core/src/main/java/fj/data/IOW.java           | 45 -------------------
 core/src/main/java/fj/data/SafeIO.java        |  1 +
 demo/src/main/java/fj/demo/IOWalkthrough.java |  3 +-
 4 files changed, 30 insertions(+), 47 deletions(-)
 delete mode 100644 core/src/main/java/fj/data/IOW.java

diff --git a/core/src/main/java/fj/data/IO.java b/core/src/main/java/fj/data/IO.java
index ee27bdb7..992abaf2 100644
--- a/core/src/main/java/fj/data/IO.java
+++ b/core/src/main/java/fj/data/IO.java
@@ -4,6 +4,9 @@
  * Created by MarkPerry on 19/06/2014.
  */
 
+import fj.F;
+import fj.Unit;
+
 import java.io.IOException;
 
 /**
@@ -13,8 +16,33 @@
  *
  * @param <A> the type of the result produced by the IO
  */
+@FunctionalInterface
 public interface IO<A> {
 
 	A run() throws IOException;
 
+	default SafeIO<Validation<IOException, A>> safe() {
+		return IOFunctions.toSafeValidation(this);
+	}
+
+	default <B> IO<B> map(F<A, B> f) {
+		return IOFunctions.map(this, f);
+	}
+
+	default <B> IO<B> bind(F<A, IO<B>> f) {
+		return IOFunctions.bind(this, f);
+	}
+
+	default <B> IO<B> append(IO<B> iob) {
+		return IOFunctions.append(this, iob);
+	}
+
+	public static IO<LazyString> getContents() {
+		return () -> IOFunctions.getContents().run();
+	}
+
+	public static IO<Unit> interact(F<LazyString, LazyString> f) {
+		return () -> IOFunctions.interact(f).run();
+	}
+
 }
diff --git a/core/src/main/java/fj/data/IOW.java b/core/src/main/java/fj/data/IOW.java
deleted file mode 100644
index 859c9cdb..00000000
--- a/core/src/main/java/fj/data/IOW.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package fj.data;
-
-import fj.F;
-import fj.Unit;
-
-import java.io.IOException;
-
-/**
- * Created by MarkPerry on 9/06/2015.
- */
-public final class IOW<A> implements IO<A> {
-
-    private final IO<A> io;
-
-    private IOW(IO<A> in) {
-        io = in;
-    }
-
-    public static <A> IOW<A> lift(IO<A> io) {
-        return new IOW<>(io);
-    }
-
-    @Override
-    public A run() throws IOException {
-        return io.run();
-    }
-
-    public SafeIO<Validation<IOException, A>> safe() {
-        return IOFunctions.toSafeValidation(io);
-    }
-
-    public <B> IOW<B> map(F<A, B> f) { return lift(IOFunctions.map(io, f)); }
-
-    public <B> IOW<B> bind(F<A, IO<B>> f) { return lift(IOFunctions.bind(io, f)); }
-
-    public <B> IOW<B> append(IO<B> iob) { return lift(IOFunctions.append(io, iob)); }
-
-    public static IOW<LazyString> getContents() {
-        return lift(() -> IOFunctions.getContents().run());
-    }
-
-    public static IOW<Unit> interact(F<LazyString, LazyString> f) {
-        return lift(() -> IOFunctions.interact(f).run());
-    }
-}
diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index ef4c608c..11fdc31a 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -3,6 +3,7 @@
 /**
  * Created by MarkPerry on 3/07/2014.
  */
+@FunctionalInterface
 public interface SafeIO<A> extends IO<A> {
 
 	@Override
diff --git a/demo/src/main/java/fj/demo/IOWalkthrough.java b/demo/src/main/java/fj/demo/IOWalkthrough.java
index 5c1c4663..2f1cb9eb 100644
--- a/demo/src/main/java/fj/demo/IOWalkthrough.java
+++ b/demo/src/main/java/fj/demo/IOWalkthrough.java
@@ -4,7 +4,6 @@
 import fj.Unit;
 import fj.data.IO;
 import fj.data.IOFunctions;
-import fj.data.IOW;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -72,7 +71,7 @@ public static void main(String[] args) {
         // for composing IO values instead, the entire program can be written like so:
 
         F<String, String> f = String::toUpperCase;
-        IOW.lift(stdoutPrintln("What's your name again?"))
+        stdoutPrintln("What's your name again?")
                 .append(stdoutPrint("Name: "))
                 .append(stdinReadLine())
                 .bind(f.andThen(IOFunctions::stdoutPrintln))

From ef68abe9ecdf083cdfecc2b0c6c367073d0a4867 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 5 Apr 2021 12:18:51 +1000
Subject: [PATCH 293/336] Removed deprecated monoid methods

---
 core/src/main/java/fj/Monoid.java | 51 +------------------------------
 1 file changed, 1 insertion(+), 50 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 96d24b82..765026b3 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -466,20 +466,6 @@ public A append(A a1, A a2) {
     });
   }
 
-  /**
-   * Constructs a monoid from the given semigroup and zero value, which must follow the monoidal laws.
-   * @deprecated since 4.7. Use {@link #monoidDef(Semigroup.Definition, Object)} or {@link Semigroup#monoid(Object)} instead.
-   *
-   * @param s    The semigroup for the monoid.
-   * @param zero The zero for the monoid.
-   * @return A monoid instance that uses the given sun function and zero value.
-   */
-  @Deprecated
-  public static <A> Monoid<A> monoid(final Semigroup<A> s, final A zero) {
-    return s.monoid(zero);
-  }
-
-
   /**
    * A monoid that adds integers.
    */
@@ -528,19 +514,7 @@ public Integer multiply(int n, Integer integer) {
       return n <= 0 ? 1 : (int) StrictMath.pow(integer.doubleValue(), n);
     }
   });
-
-  /**
-   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
-   */
-  @Deprecated
-  public static final Monoid<Double> doubleAdditionMonoid = monoidDef((d1, d2) -> d1 + d2, 0.0);
-
-  /**
-   * @deprecated Since 4.7. Due to rounding errors, multiplication of doubles does not comply with monoid laws
-   */
-  @Deprecated
-  public static final Monoid<Double> doubleMultiplicationMonoid = monoidDef((d1, d2) -> d1 * d2, 1.0);
-
+  
   /**
    * A monoid that adds big integers.
    */
@@ -889,17 +863,6 @@ public Option<A> sum(F0<Stream<Option<A>>> oas) {
     });
   }
 
-  /**
-   * A monoid for options.
-   * @deprecated since 4.7. Use {@link #firstOptionMonoid()}.
-   *
-   * @return A monoid for options.
-   */
-  @Deprecated
-  public static <A> Monoid<Option<A>> optionMonoid() {
-    return firstOptionMonoid();
-  }
-
   /**
    * A monoid for options that take the first available value.
    *
@@ -1121,16 +1084,4 @@ public Set<A> append(Set<A> a1, Set<A> a2) {
     });
   }
 
-  /**
-   * A monoid for the maximum of elements with ordering o.
-   * @deprecated since 4.7. Use {@link Ord#maxMonoid(Object)}
-   *
-   * @param o An ordering of elements.
-   * @param zero The minimum element.
-   */
-  @Deprecated
-  public static <A> Monoid<A> ordMaxMonoid(final Ord<A> o, final A zero) {
-    return o.maxMonoid(zero);
-  }
-
 }

From 3b0f9b951f0a503b6326c1e40f48c43d6d381683 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 5 Apr 2021 13:27:22 +1000
Subject: [PATCH 294/336] Removed deprecated methods from core

---
 core/src/main/java/fj/Monoid.java         |  2 +-
 core/src/main/java/fj/Ord.java            | 38 ----------
 core/src/main/java/fj/P.java              |  7 ++
 core/src/main/java/fj/P1.java             | 31 +-------
 core/src/main/java/fj/Semigroup.java      | 23 ------
 core/src/main/java/fj/data/Array.java     | 13 ----
 core/src/main/java/fj/data/HashMap.java   | 20 -----
 core/src/main/java/fj/data/Java.java      | 11 ---
 core/src/main/java/fj/data/List.java      | 90 -----------------------
 core/src/main/java/fj/data/Seq.java       | 16 ----
 core/src/main/java/fj/data/Set.java       | 24 ------
 core/src/main/java/fj/data/Stream.java    | 53 -------------
 core/src/main/java/fj/data/TreeMap.java   | 20 +----
 core/src/test/java/fj/data/ArrayTest.java |  1 +
 14 files changed, 13 insertions(+), 336 deletions(-)

diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index 765026b3..bc09250d 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -514,7 +514,7 @@ public Integer multiply(int n, Integer integer) {
       return n <= 0 ? 1 : (int) StrictMath.pow(integer.doubleValue(), n);
     }
   });
-  
+
   /**
    * A monoid that adds big integers.
    */
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index eef729c4..ae4d3fda 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -687,44 +687,6 @@ public static <A extends Comparable<A>> Ord<A> comparableOrd() {
     return ordDef((a1, a2) -> Ordering.fromInt(a1.compareTo(a2)));
   }
 
-  /**
-   * An order instance that uses {@link Object#hashCode()} for computing the order and equality,
-   * thus objects returning the same hashCode are considered to be equals.
-   * This is not safe and therefore this method is deprecated.
-   *
-   * @return An order instance that is based on {@link Object#hashCode()}.
-   *
-   * @deprecated As of release 4.7.
-   */
-  @Deprecated
-  public static <A> Ord<A> hashOrd() {
-    return ordDef(a -> {
-      int aHash = a.hashCode();
-      return a2 -> Ordering.fromInt(Integer.valueOf(aHash).compareTo(a2.hashCode()));
-    });
-  }
-
-  /**
-   * An order instance that uses {@link Object#hashCode()} and {@link Object#equals} for computing
-   * the order and equality. First the hashCode is compared, if this is equal, objects are compared
-   * using {@link Object#equals}.
-   * WARNING: This ordering violate antisymmetry on hash collisions.
-   *
-   * @return An order instance that is based on {@link Object#hashCode()} and {@link Object#equals}.
-   *
-   * @deprecated As of release 4.7.
-   */
-  @Deprecated
-  public static <A> Ord<A> hashEqualsOrd() {
-    return ordDef(a -> {
-      int aHash = a.hashCode();
-      return a2 -> {
-        final int a2Hash = a2.hashCode();
-        return aHash < a2Hash ? Ordering.LT : aHash == a2Hash && a.equals(a2) ? Ordering.EQ : Ordering.GT;
-      };
-    });
-  }
-
   class OrdComparator implements Comparator<A> {
 	@Override
     public final int compare(A o1, A o2) {
diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index 6d174ed7..587cdc9d 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -65,6 +65,13 @@ public static <A> P1<A> softMemo(F0<A> f) {
     return new P1.SoftReferenceMemo<>(f);
   }
 
+    /**
+     * Convert a F0 into a P1, using weak call-by-need semantic using {@link #weakMemo(F0)}.
+     */
+    public static <A> P1<A> memo(F0<A> f) {
+        return weakMemo(f);
+    }
+
   /**
    * Convert a F0 into a P1, using call-by-name semantic:
    * function f is evaluated at each call to {@link P1#_1()}.
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 420b820b..810e484d 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -39,18 +39,6 @@ public static <A> F<P1<A>, A> __1() {
         return P1::_1;
     }
 
-    /**
-     * Promote any function to a transformation between P1s.
-     *
-     * @deprecated As of release 4.5, use {@link #map_}
-     * @param f A function to promote to a transformation between P1s.
-     * @return A function promoted to operate on P1s.
-     */
-    @Deprecated
-    public static <A, B> F<P1<A>, P1<B>> fmap(final F<A, B> f) {
-        return map_(f);
-    }
-
 	/**
 	 * Promote any function to a transformation between P1s.
 	 *
@@ -243,9 +231,8 @@ public final <B> P1<B> map(final F<A, B> f) {
       }
 
     /**
-     * @deprecated since 4.7. Use {@link P1#weakMemo()} instead.
+     * Wrap the memoized value into a <code>WeakReference</code>.
      */
-    @Deprecated
     public final P1<A> memo() {
         return weakMemo();
     }
@@ -267,22 +254,6 @@ public final P1<A> memo() {
      */
     public P1<A> softMemo() { return new SoftReferenceMemo<>(this); }
 
-    /**
-     * @deprecated since 4.7. Use {@link P#weakMemo(F0)} instead.
-     */
-    @Deprecated
-    public static <A> P1<A> memo(F<Unit, A> f) {
-        return P.weakMemo(() -> f.f(unit()));
-    }
-
-  /**
-   * @deprecated since 4.7. Use {@link P#weakMemo(F0)} instead.
-   */
-  @Deprecated
-  public static <A> P1<A> memo(F0<A> f) {
-		return P.weakMemo(f);
-	}
-
     static final class Memo<A> extends P1<A> {
       private volatile F0<A> fa;
       private A value;
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 6fbc5fc6..1d767385 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -292,23 +292,11 @@ public static <A> Semigroup<A> semigroup(final F2<A, A, A> sum) {
    */
   public static final Semigroup<Integer> intAdditionSemigroup = intAdditionMonoid.semigroup();
 
-  /**
-   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
-   */
-  @Deprecated
-  public static final Semigroup<Double> doubleAdditionSemigroup = semigroupDef((d1, d2) -> d1 + d2);
-
   /**
    * A semigroup that multiplies integers.
    */
   public static final Semigroup<Integer> intMultiplicationSemigroup = intMultiplicationMonoid.semigroup();
 
-  /**
-   * @deprecated Since 4.7. Due to rounding errors, addition of doubles does not comply with monoid laws
-   */
-  @Deprecated
-  public static final Semigroup<Double> doubleMultiplicationSemigroup = semigroupDef((d1, d2) -> d1 * d2);
-
   /**
    * A semigroup that yields the maximum of integers.
    */
@@ -520,17 +508,6 @@ public NonEmptyList<A> sum(NonEmptyList<A> nea, F0<Stream<NonEmptyList<A>>> neas
     });
   }
 
-  /**
-   * A semigroup for optional values.
-   * @deprecated since 4.7. Use {@link #firstOptionSemigroup()}.
-   *
-   * @return A semigroup for optional values.
-   */
-  @Deprecated
-  public static <A> Semigroup<Option<A>> optionSemigroup() {
-    return firstOptionSemigroup();
-  }
-
   /**
    * A semigroup for optional values that take the first available value.
    *
diff --git a/core/src/main/java/fj/data/Array.java b/core/src/main/java/fj/data/Array.java
index 7e937200..fb245f3f 100755
--- a/core/src/main/java/fj/data/Array.java
+++ b/core/src/main/java/fj/data/Array.java
@@ -130,19 +130,6 @@ public Object[] array() {
     return copyOf(a, a.length);
   }
 
-  /**
-   * To be removed in future release:
-   * affectation of the result of this method to a non generic array
-   * will result in runtime error (ClassCastException).
-   *
-   * @deprecated As of release 4.6, use {@link #array(Class)}.
-   */
-  @SuppressWarnings("unchecked")
-  @Deprecated
-  public A[] toJavaArray() {
-    return (A[]) array();
-  }
-
   /**
    * Returns an option projection of this array; <code>None</code> if empty, or the first element in
    * <code>Some</code>.
diff --git a/core/src/main/java/fj/data/HashMap.java b/core/src/main/java/fj/data/HashMap.java
index 400cf415..455c529c 100755
--- a/core/src/main/java/fj/data/HashMap.java
+++ b/core/src/main/java/fj/data/HashMap.java
@@ -325,16 +325,6 @@ public java.util.Map<K, V> toMap() {
     return result;
   }
 
-  /**
-   * Converts the Iterable to a HashMap
-   *
-   * @deprecated As of release 4.5, use {@link #iterableHashMap(Iterable)}
-   */
-  @Deprecated
-  public static <K, V> HashMap<K, V> from(final Iterable<P2<K, V>> entries) {
-    return iterableHashMap(entries);
-  }
-
   public static <K, V> HashMap<K, V> fromMap(java.util.Map<K, V> map) {
     return fromMap(Equal.anyEqual(), Hash.anyHash(), map);
   }
@@ -347,16 +337,6 @@ public static <K, V> HashMap<K, V> fromMap(Equal<K> eq, Hash<K> h, java.util.Map
     return m;
   }
 
-  /**
-   * Converts the Iterable to a HashMap
-   *
-   * @deprecated As of release 4.5, use {@link #iterableHashMap}
-   */
-  @Deprecated
-  public static <K, V> HashMap<K, V> from(final Iterable<P2<K, V>> entries, final Equal<K> equal, final Hash<K> hash) {
-    return iterableHashMap(equal, hash, entries);
-  }
-
   /**
    * Converts the Iterable to a HashMap
    */
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index ae7fcf6a..8691c09d 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -1414,17 +1414,6 @@ public static <A> F<ArrayList<A>, List<A>> ArrayList_List() {
 
   // END ArrayList ->
 
-  /**
-   * A function that converts Java lists to lists.
-   * @deprecated As of 4.3, use {@link #JavaList_List}
-   *
-   * @return A function that converts Java lists to lists.
-   */
-  @Deprecated
-  public static <A> F<java.util.List<A>, List<A>> JUList_List() {
-    return Java::JavaList_List;
-  }
-
   public static <A> F<java.util.List<A>, List<A>> JavaList_List() {
     return Java::JavaList_List;
   }
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 5b5fff67..447f76a5 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -86,19 +86,6 @@ public final boolean isNotEmpty() {
     return this instanceof Cons;
   }
 
-  /**
-   * Performs a reduction on this list using the given arguments.
-   * @deprecated As of release 4.5, use {@link #uncons}
-   *
-   * @param nil  The value to return if this list is empty.
-   * @param cons The function to apply to the head and tail of this list if it is not empty.
-   * @return A reduction on this list.
-   */
-  @Deprecated
-  public final <B> B list(final B nil, final F<A, F<List<A>, B>> cons) {
-    return uncons(uncurryF2(cons), nil);
-  }
-
   public final <B> B uncons(final F2<A, List<A>, B> cons, final B nil) {
     return isEmpty() ? nil : cons.f(head(), tail());
   }
@@ -123,18 +110,6 @@ public final List<A> orTail(final F0<List<A>> as) {
     return isEmpty() ? as.f() : tail();
   }
 
-  /**
-   * Returns an option projection of this list; <code>None</code> if empty, or the first element in
-   * <code>Some</code>.  Equivalent to {@link #headOption()}.
-   * @deprecated As of release 4.5, use {@link #headOption()}
-   * @return An option projection of this list.
-   */
-  @Deprecated
-  public final Option<A> toOption() {
-    return headOption();
-
-  }
-
   /**
    * Returns the head of the list, if any.  Equivalent to {@link #toOption()} .
    *
@@ -185,19 +160,6 @@ public final Object[] toArrayObject() {
     return a;
   }
 
-  /**
-   * To be removed in future release:
-   * affectation of the result of this method to a non generic array
-   * will result in runtime error (ClassCastException).
-   *
-   * @deprecated As of release 4.6, use {@link #array(Class)}.
-   */
-  @SuppressWarnings("unchecked")
-  @Deprecated
-  public final A[] toJavaArray() {
-    return (A[]) toArrayObject();
-  }
-
   /**
    * Returns a array projection of this list.
    *
@@ -1529,21 +1491,6 @@ public final A mode(final Ord<A> o) {
     return sort(o).group(o.equal()).maximum(intOrd.contramap(List.length_())).head();
   }
 
-  /**
-   * Groups the elements of this list by a given keyFunction into a {@link TreeMap}.
-   * The ordering of the keys is determined by {@link fj.Ord#hashOrd()} (ie. Object#hasCode).
-   * This is not safe and therefore this method is deprecated.
-   *
-   * @param keyFunction The function to select the keys for the map.
-   * @return A TreeMap containing the keys with the accumulated list of matched elements.
-   *
-   * @deprecated As of release 4.7, use {@link #groupBy(F, Ord)}
-   */
-  @Deprecated
-  public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction) {
-    return groupBy(keyFunction, Ord.hashOrd());
-  }
-
   /**
    * Groups the elements of this list by a given keyFunction into a {@link TreeMap}.
    *
@@ -1555,25 +1502,6 @@ public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction, final Or
     return groupBy(keyFunction, identity(), keyOrd);
   }
 
-  /**
-   * Groups the elements of this list by a given keyFunction into a {@link TreeMap} and transforms
-   * the matching elements with the given valueFunction. The ordering of the keys is determined by
-   * {@link fj.Ord#hashOrd()} (ie. Object#hasCode).
-   * This is not safe and therefore this method is deprecated.
-   *
-   * @param keyFunction The function to select the keys for the map.
-   * @param valueFunction The function to apply on each matching value.
-   * @return A TreeMap containing the keys with the accumulated list of matched and mapped elements.
-   *
-   * @deprecated As of release 4.7, use {@link #groupBy(F, F, Ord)}
-   */
-  @Deprecated
-  public final <B, C> TreeMap<B, List<C>> groupBy(
-      final F<A, B> keyFunction,
-      final F<A, C> valueFunction) {
-    return this.groupBy(keyFunction, valueFunction, Ord.hashOrd());
-  }
-
   /**
    * Groups the elements of this list by a given keyFunction into a {@link TreeMap} and transforms
    * the matching elements with the given valueFunction. The ordering of the keys is determined by
@@ -1821,24 +1749,6 @@ public static <A> List<A> arrayList(final A... as) {
     return Array.array(as).toList();
   }
 
-  /**
-   * Constructs a list from the given Iterable.
-   * @deprecated As of release 4.5, use {@link #iterableList(Iterable)}
-   */
-  @Deprecated
-  public static <A> List<A> list(final Iterable<A> i) {
-    return iterableList(i);
-  }
-
-  /**
-   * Constructs a list from the given Iterator.
-   * @deprecated As of release 4.5, use {@link #iteratorList(Iterator)}
-   */
-  @Deprecated
-  public static <A> List<A> list(final Iterator<A> it) {
-    return iteratorList(it);
-  }
-
   /**
    * Constructs a list from the given Iterator.
    */
diff --git a/core/src/main/java/fj/data/Seq.java b/core/src/main/java/fj/data/Seq.java
index 3bcb7033..59a46df7 100644
--- a/core/src/main/java/fj/data/Seq.java
+++ b/core/src/main/java/fj/data/Seq.java
@@ -78,25 +78,9 @@ public static <A> Seq<A> single(final A a) {
   /**
    * Constructs a sequence from the given list.
    *
-   * @deprecated As of release 4.5, use {@link #listSeq(List)}
-   *
-   * @param list The list to create the sequence from.
-   * @return A sequence with the given elements in the list.
-   */
-  @Deprecated
-  public static <A>Seq<A> seq(final List<A> list) {
-    return iterableSeq(list);
-  }
-
-  /**
-   * Constructs a sequence from the given list.
-   *
-   * @deprecated As of release 4.5, use {@link #iterableSeq}
-   *
    * @param list The list to create the sequence from.
    * @return A sequence with the elements of the list.
    */
-  @Deprecated
   public static <A>Seq<A> listSeq(final List<A> list) {
     return iterableSeq(list);
   }
diff --git a/core/src/main/java/fj/data/Set.java b/core/src/main/java/fj/data/Set.java
index 15207d83..4c0aeaa0 100644
--- a/core/src/main/java/fj/data/Set.java
+++ b/core/src/main/java/fj/data/Set.java
@@ -713,28 +713,4 @@ public static <A> Set<A> arraySet(final Ord<A> o, final A...as) {
     return arraySet(o, as);
   }
 
-  /**
-   * Constructs a set from the list.
-   *
-   * @deprecated As of release 4.5, use {@link #iterableSet}
-   *
-   * @param o  An order for the elements of the new set.
-   * @param list The elements to add to a set.
-   * @return A new set containing the elements of the given list.
-   */
-  @Deprecated
-  public static <A> Set<A> set(final Ord<A> o, List<A> list) {
-    return iterableSet(o, list);
-  }
-
-  /**
-   * Constructs a set from the list.
-   *
-   * @deprecated As of release 4.5, use {@link #iterableSet}
-   */
-  @Deprecated
-  public static <A> Set<A> fromList(final Ord<A> o, List<A> list) {
-    return iterableSet(o, list);
-  }
-
 }
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index e05e26bf..bcf87dcf 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -89,20 +89,6 @@ public final boolean isNotEmpty() {
     return this instanceof Cons;
   }
 
-  /**
-   * Performs a reduction on this stream using the given arguments.  Equivalent to {@link #uncons}.
-   *
-   * @deprecated As of release 4.5, use {@link #uncons}
-   *
-   * @param nil  The value to return if this stream is empty.
-   * @param cons The function to apply to the head and tail of this stream if it is not empty.
-   * @return A reduction on this stream.
-   */
-  @Deprecated
-  public final <B> B stream(final B nil, final F<A, F<P1<Stream<A>>, B>> cons) {
-    return uncons(nil, cons);
-  }
-
   /**
    * Performs a reduction on this stream using the given arguments.
    *
@@ -712,26 +698,6 @@ public static Stream<Integer> range(final int from, final long to) {
     return arrayStream(as);
   }
 
-  /**
-   * Constructs a stream with the given elements in the Iterable.  Equivalent to {@link #iterableStream(Iterable)} .
-   *
-   * @deprecated As of release 4.5, use {@link #iterableStream(Iterable)}
-   */
-  @Deprecated
-  public static <A> Stream<A> stream(Iterable<A> it) {
-    return iterableStream(it);
-  }
-
-  /**
-   * Constructs a stream with the given elements in the Iterator.  Equivalent to {@link #iteratorStream(Iterator)} .
-   *
-   * @deprecated As of release 4.5, use {@link #iteratorStream(Iterator)}
-   */
-  @Deprecated
-  public static <A> Stream<A> stream(final Iterator<A> it) {
-    return iteratorStream(it);
-  }
-
   /**
    * Constructs a stream with the given elements in the Iterator.
    */
@@ -916,25 +882,6 @@ public final Option<A> toOption() {
     return isEmpty() ? Option.none() : some(head());
   }
 
-  /**
-   * To be removed in future release:
-   * affectation of the result of this method to a non generic array
-   * will result in runtime error (ClassCastException).
-   *
-   * @deprecated As of release 4.6, use {@link #array(Class)}.
-   */
-  @Deprecated
-  public final A[] toJavaArray() {
-    @SuppressWarnings("unchecked")
-    final A[] array = (A[]) new Object[length()];
-    int i = 0;
-    for (A a: this) {
-      array[i] = a;
-      i++;
-    }
-    return array;
-  }
-
   /**
    * Returns a list projection of this stream.
    *
diff --git a/core/src/main/java/fj/data/TreeMap.java b/core/src/main/java/fj/data/TreeMap.java
index 38607dbc..e1af4d91 100644
--- a/core/src/main/java/fj/data/TreeMap.java
+++ b/core/src/main/java/fj/data/TreeMap.java
@@ -69,20 +69,6 @@ public String toString() {
     return arrayTreeMap(keyOrd, p2s);
   }
 
-  /**
-   * Constructs a tree map from the given elements.
-   *
-   * @deprecated As of release 4.5, use {@link #iterableTreeMap(Ord, Iterable)}
-   *
-   * @param keyOrd An order for the keys of the tree map.
-   * @param list The elements to construct the tree map with.
-   * @return a TreeMap with the given elements.
-   */
-  @Deprecated
-  public static <K, V> TreeMap<K, V> treeMap(final Ord<K> keyOrd, final List<P2<K, V>> list) {
-    return iterableTreeMap(keyOrd, list);
-  }
-
   /**
    * Constructs a tree map from the given elements.
    *
@@ -313,12 +299,12 @@ public P3<Set<V>, Option<V>, Set<V>> split(Ord<V> ord, final K k) {
   }
 
   /**
-   * Internal construction of a TreeMap from the given set.
+   * Constructs a TreeMap from the given set.
    * @param ord An order for the keys of the tree map.
    * @param s The elements to construct the tree map with.
    * @return a TreeMap with the given elements.
    */
-  private static <K, V> TreeMap<K, V> treeMap(Ord<K> ord, Set<P2<K, Option<V>>> s) {
+  public static <K, V> TreeMap<K, V> setTreeMap(Ord<K> ord, Set<P2<K, Option<V>>> s) {
     TreeMap<K, V> empty = TreeMap.empty(ord);
     TreeMap<K, V> tree = s.toList().foldLeft((tm, p2) -> {
       Option<V> opt = p2._2();
@@ -347,7 +333,7 @@ private static <K, V> TreeMap<K, V> treeMap(Ord<K> ord, Set<P2<K, Option<V>>> s)
   public P3<TreeMap<K, V>, Option<V>, TreeMap<K, V>> splitLookup(final K k) {
     P3<Set<P2<K, Option<V>>>, Option<P2<K, Option<V>>>, Set<P2<K, Option<V>>>> p3 = tree.split(p(k, get(k)));
     Ord<K> o = tree.ord().contramap(k2 -> p(k2, Option.none()));
-    return p(treeMap(o, p3._1()), get(k), treeMap(o, p3._3()));
+    return p(setTreeMap(o, p3._1()), get(k), setTreeMap(o, p3._3()));
   }
 
   /**
diff --git a/core/src/test/java/fj/data/ArrayTest.java b/core/src/test/java/fj/data/ArrayTest.java
index 886031b3..883fc835 100644
--- a/core/src/test/java/fj/data/ArrayTest.java
+++ b/core/src/test/java/fj/data/ArrayTest.java
@@ -1,5 +1,6 @@
 package fj.data;
 
+import org.hamcrest.CoreMatchers;
 import org.junit.Test;
 
 import static org.hamcrest.CoreMatchers.equalTo;

From e6234b801de460ff759aafeb4674edaf3c32c503 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 5 Apr 2021 15:54:41 +1000
Subject: [PATCH 295/336] Removed deprecated methods from quickcheck

---
 quickcheck/src/main/java/fj/test/Gen.java  | 33 ------------------
 quickcheck/src/main/java/fj/test/Rand.java | 39 +++-------------------
 2 files changed, 5 insertions(+), 67 deletions(-)

diff --git a/quickcheck/src/main/java/fj/test/Gen.java b/quickcheck/src/main/java/fj/test/Gen.java
index dabaf9a6..8fe1e6f5 100644
--- a/quickcheck/src/main/java/fj/test/Gen.java
+++ b/quickcheck/src/main/java/fj/test/Gen.java
@@ -536,24 +536,6 @@ public static <A> Gen<A> pickOne(List<A> as) {
     return wordOf(1, as).map(List::head);
   }
 
-  /**
-   * Returns a generator of lists that picks the given number of elements from the given list. If
-   * the given number is less than zero or greater than the length of the given list, then the
-   * returned generator will never produce a value.
-   * <p>
-   * Note: pick is synonymous with combinationOf
-   *
-   * @deprecated As of release 4.6, use {@link #combinationOf}
-   *
-   * @param n  The number of elements to pick from the given list.
-   * @param as The list from which to pick elements.
-   * @return A generator of lists that picks the given number of elements from the given list.
-   */
-  @Deprecated
-  public static <A> Gen<List<A>> pick(int n, List<A> as) {
-    return combinationOf(n, as);
-  }
-
   /**
    * Returns a generator of lists that picks the given number of elements from the given list. The selection is
    * a combination without replacement of elements from the given list, i.e.
@@ -678,21 +660,6 @@ private static <A> Gen<List<A>> pick(Gen<List<Integer>> indexesGen, Array<A> as)
         indexes.foldLeft((acc, index) -> cons(as.get(index), acc), List.<A>nil()).reverse());
   }
 
-  /**
-   * Returns a generator of lists that produces some of the values of the given list.
-   * <p>
-   * Note: someOf is synonymous with someCombinationOf
-   *
-   * @deprecated As of release 4.6, use {@link #someCombinationOf}
-   *
-   * @param as The list from which to pick values.
-   * @return A generator of lists that produces some of the values of the given list.
-   */
-  @Deprecated
-  public static <A> Gen<List<A>> someOf(List<A> as) {
-    return someCombinationOf(as);
-  }
-
   /**
    * Returns a generator of lists that produces some of the values of the given list. The selection is
    * a combination without replacement of elements from the given list, i.e.
diff --git a/quickcheck/src/main/java/fj/test/Rand.java b/quickcheck/src/main/java/fj/test/Rand.java
index b622dfe7..e47aa8a8 100644
--- a/quickcheck/src/main/java/fj/test/Rand.java
+++ b/quickcheck/src/main/java/fj/test/Rand.java
@@ -5,7 +5,6 @@
 
 import java.util.Random;
 
-import static fj.data.Option.none;
 import static fj.data.Option.some;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
@@ -18,18 +17,16 @@
 public final class Rand {
   private final F<Option<Long>, F<Integer, F<Integer, Integer>>> f;
   private final F<Option<Long>, F<Double, F<Double, Double>>> g;
-
-  // TODO Change to F<Long,Rand> when rand(f,g) is removed
-  private final Option<F<Long, Rand>> optOnReseed;
+  private final F<Long, Rand> onReseed;
 
   private Rand(
       F<Option<Long>, F<Integer, F<Integer, Integer>>> f,
       F<Option<Long>, F<Double, F<Double, Double>>> g,
-      Option<F<Long, Rand>> optOnReseed) {
+      F<Long, Rand> onReseed) {
 
     this.f = f;
     this.g = g;
-    this.optOnReseed = optOnReseed;
+    this.onReseed = onReseed;
   }
 
   /**
@@ -88,33 +85,7 @@ public double choose(final double from, final double to) {
    * @return A random generator with the given seed.
    */
   public Rand reseed(long seed) {
-    return optOnReseed.<Rand>option(
-        () -> {
-          throw new IllegalStateException("reseed() called on a Rand created with deprecated rand() method");
-        },
-        onReseed -> onReseed.f(seed));
-  }
-
-  /**
-   * Constructs a random generator from the given functions that supply a range to produce a
-   * result.
-   * <p>
-   * Calling {@link #reseed(long)} on an instance returned from this method will
-   * result in an exception being thrown.
-   *
-   * @deprecated As of release 4.6, use {@link #rand(F, F, F)}.
-   *
-   * @param f The integer random generator.
-   * @param g The floating-point random generator.
-   * @return A random generator from the given functions that supply a range to produce a result.
-   */
-  // TODO Change Option<F<Long,Rand>> optOnReseed to F<Long,Road> onReseed when removing this method
-  @Deprecated
-  public static Rand rand(
-      F<Option<Long>, F<Integer, F<Integer, Integer>>> f,
-      F<Option<Long>, F<Double, F<Double, Double>>> g) {
-
-    return new Rand(f, g, none());
+    return onReseed.f(seed);
   }
 
   /**
@@ -131,7 +102,7 @@ public static Rand rand(
       F<Option<Long>, F<Double, F<Double, Double>>> g,
       F<Long, Rand> onReseed) {
 
-    return new Rand(f, g, some(onReseed));
+    return new Rand(f, g, onReseed);
   }
 
   /**

From 4859b75a3837c4c772c65c46596f388e7c1627b3 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Tue, 6 Apr 2021 01:53:30 +1000
Subject: [PATCH 296/336] Added partial Either3 implementation

---
 core/src/main/java/fj/Equal.java            |   8 +
 core/src/main/java/fj/Hash.java             |   7 +-
 core/src/main/java/fj/Show.java             |  10 +
 core/src/main/java/fj/data/Either3.java     | 226 ++++++++++++++++++++
 core/src/test/java/fj/data/Either3Test.java |   6 +
 5 files changed, 256 insertions(+), 1 deletion(-)
 create mode 100644 core/src/main/java/fj/data/Either3.java
 create mode 100644 core/src/test/java/fj/data/Either3Test.java

diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 5cd31aeb..9179cc43 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -357,6 +357,14 @@ public static <A, B> Equal<Either<A, B>> eitherEqual(final Equal<A> ea, final Eq
     ));
   }
 
+  public static <A, B, C> Equal<Either3<A, B, C>> either3Equal(Equal<A> ea, Equal<B> eb, Equal<C> ec) {
+    return equalDef((e1, e2) ->
+      optionEqual(ea).eq(e1.leftOption(), e2.leftOption()) &&
+      optionEqual(eb).eq(e1.middleOption(), e2.middleOption()) &&
+      optionEqual(ec).eq(e1.rightOption(), e2.rightOption())
+    );
+  }
+
   public static <I, A> Equal<Result<I, A>> resultEqual(final Equal<A> ea, final Equal<I> ei) {
     Definition<A> eaDef = ea.def;
     Definition<I> eiDef= ei.def;
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 8d0a4e4c..703d96ee 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -163,7 +163,12 @@ public static <A, B> Hash<Either<A, B>> eitherHash(final Hash<A> ha, final Hash<
     return hash(e -> e.isLeft() ? ha.hash(e.left().value()) : hb.hash(e.right().value()));
   }
 
-  /**
+    public static <A, B, C> Hash<Either3<A, B, C>> either3Hash(final Hash<A> ha, final Hash<B> hb, final Hash<C> hc) {
+        return hash(e -> e.either(a -> ha.hash(a), b -> hb.hash(b), c -> hc.hash(c)));
+    }
+
+
+    /**
    * A hash instance for the {@link Result} type.
    *
    * @param ha Hash the <code>Result</code> value.
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index cd57897b..62da5273 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -256,6 +256,16 @@ public static <A, B> Show<Either<A, B>> eitherShow(final Show<A> sa, final Show<
            fromString("Right(").append(sb.f.f(e.right().value())).append(single(')')));
   }
 
+  public static <A, B, C> Show<Either3<A, B, C>> eitherShow(final Show<A> sa, final Show<B> sb, final Show<C> sc) {
+    return show(e ->
+      e.either(
+        a -> fromString("Left(").append(sa.f.f(a)).append(single(')')),
+        b -> fromString("Middle(").append(sb.f.f(b)).append(single(')')),
+        c -> fromString("Right(").append(sc.f.f(c)).append(single(')'))
+      )
+    );
+  }
+
   /**
    * A show instance for the {@link Result} type.
    *
diff --git a/core/src/main/java/fj/data/Either3.java b/core/src/main/java/fj/data/Either3.java
new file mode 100644
index 00000000..8c6b7344
--- /dev/null
+++ b/core/src/main/java/fj/data/Either3.java
@@ -0,0 +1,226 @@
+package fj.data;
+
+import fj.Equal;
+import fj.F;
+import fj.F0;
+import fj.Hash;
+
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+
+public abstract class Either3<A, B, C> {
+
+    private Either3() {}
+
+    private static final class Left<A, B, C> extends Either3<A, B, C> {
+        A a;
+        Left(A a) {
+            this.a = a;
+        }
+
+        @Override
+        public boolean isLeft() {
+            return true;
+        }
+
+        @Override
+        public boolean isMiddle() {
+            return false;
+        }
+
+        @Override
+        public boolean isRight() {
+            return false;
+        }
+
+        @Override
+        public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
+            return fa.f(a);
+        }
+    }
+
+    private static final class Middle<A, B, C> extends Either3<A, B, C> {
+        B b;
+        Middle(B b) {
+            this.b = b;
+        }
+
+        @Override
+        public boolean isLeft() {
+            return false;
+        }
+
+        @Override
+        public boolean isMiddle() {
+            return true;
+        }
+
+        @Override
+        public boolean isRight() {
+            return false;
+        }
+
+        @Override
+        public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
+            return fb.f(b);
+        }
+    }
+
+    private static final class Right<A, B, C> extends Either3<A, B, C> {
+        C c;
+        Right(C c) {
+            this.c = c;
+        }
+
+        @Override
+        public boolean isLeft() {
+            return false;
+        }
+
+        @Override
+        public boolean isMiddle() {
+            return false;
+        }
+
+        @Override
+        public boolean isRight() {
+            return true;
+        }
+
+        @Override
+        public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
+            return fc.f(c);
+        }
+
+    }
+
+    public static final class LeftProjection<A, B, C> {
+        private final Either3<A, B, C> e;
+
+        private LeftProjection(final Either3<A, B, C> e) {
+            this.e = e;
+        }
+
+        public <X> Either3<X, B, C> apply(final Either3<F<A, X>, B, C> e) {
+            return e.left().bind(this::map);
+        }
+
+        public boolean exists(final F<A, Boolean> f) {
+            return e.either(a -> f.f(a), b -> false, c -> false);
+        }
+
+        public <X> Either3<X, B, C> bind(F<A, Either3<X, B, C>> f) {
+            return e.either(a -> f.f(a), b -> middle(b), c -> right(c));
+        }
+
+        public <X, Y> Option<Either3<A, X, Y>> filter(final F<A, Boolean> f) {
+            return e.either(a -> f.f(a) ? some(left(a)) : none(), b -> none(), c -> none());
+        }
+
+
+        public <X> Either3<X, B, C> map(final F<A, X> f) {
+            return e.either(a -> left(f.f(a)), b -> middle(b), c -> right(c));
+        }
+
+    }
+
+    public static final class MiddleProjection<A, B, C> {
+        private final Either3<A, B, C> e;
+
+        private MiddleProjection(final Either3<A, B, C> e) {
+            this.e = e;
+        }
+
+        public <X> Either3<A, X, C> bind(F<B, Either3<A, X, C>> f) {
+            return e.either(a -> left(a), b -> f.f(b), c -> right(c));
+        }
+
+    }
+
+    public static final class RightProjection<A, B, C> {
+        private final Either3<A, B, C> e;
+
+        private RightProjection(final Either3<A, B, C> e) {
+            this.e = e;
+        }
+
+        public <X> Either3<A, B, X> bind(F<C, Either3<A, B, X>> f) {
+            return e.either(a -> left(a), b -> middle(b), c -> f.f(c));
+        }
+    }
+
+    public static <A, B, C> Either3<A, B, C> left(A a) {
+        return new Left<>(a);
+    }
+
+    public static <A, B, C> Either3<A, B, C> middle(B b) {
+        return new Middle<>(b);
+    }
+
+    public static <A, B, C> Either3<A, B, C> right(C c) {
+        return new Right<>(c);
+    }
+
+    public abstract boolean isLeft();
+
+    public abstract boolean isMiddle();
+
+    public abstract boolean isRight();
+
+    public <X, Y, Z> Either3<X, Y, Z> map3(F<A, X> fl, F<B, Y> fm, F<C, Z> fr) {
+        return either(
+                a -> left(fl.f(a)),
+                b -> middle(fm.f(b)),
+                c -> right(fr.f(c))
+        );
+    }
+
+    public abstract <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc);
+
+    public Either3<B, C, A> moveLeft() {
+        return either(a -> right(a), b -> left(b), c -> middle(c));
+    }
+
+    public Either3<C, A, B> moveRight() {
+        return either(a -> middle(a), b -> right(b), c -> left(c));
+    }
+
+    public Either3<C, B, A> swap() {
+        return either(a -> right(a), b -> middle(b), c -> left(c));
+    }
+
+    public Option<A> leftOption() {
+        return either(a -> some(a), b -> none(), c -> none());
+    }
+
+    public Option<B> middleOption() {
+        return either(a -> none(), b -> some(b), c -> none());
+    }
+
+    public Option<C> rightOption() {
+        return either(a -> none(), b -> none(), c -> some(c));
+    }
+
+    public final LeftProjection<A, B, C> left() {
+        return new LeftProjection<>(this);
+    }
+
+    public final MiddleProjection<A, B, C> middle() {
+        return new MiddleProjection<>(this);
+    }
+
+    public final RightProjection<A, B, C> right() {
+        return new RightProjection<>(this);
+    }
+
+    @Override
+    public final boolean equals(Object other) {
+        return Equal.equals0(Either3.class, this, other, () -> Equal.either3Equal(Equal.anyEqual(), Equal.anyEqual(), Equal.anyEqual()));
+    }
+
+    @Override
+    public final int hashCode() {
+        return Hash.either3Hash(Hash.<A>anyHash(), Hash.<B>anyHash(), Hash.<C>anyHash()).hash(this);
+    }
+
+}
diff --git a/core/src/test/java/fj/data/Either3Test.java b/core/src/test/java/fj/data/Either3Test.java
new file mode 100644
index 00000000..1507bf41
--- /dev/null
+++ b/core/src/test/java/fj/data/Either3Test.java
@@ -0,0 +1,6 @@
+package fj.data;
+
+public final class Either3Test {
+
+
+}

From d2f777d7ee57b48fe8dfe71317ec0790d39c76ab Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Tue, 6 Apr 2021 13:37:52 +1000
Subject: [PATCH 297/336] Fixed javadoc on headOption.

---
 core/src/main/java/fj/data/List.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 447f76a5..9259900f 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -111,7 +111,7 @@ public final List<A> orTail(final F0<List<A>> as) {
   }
 
   /**
-   * Returns the head of the list, if any.  Equivalent to {@link #toOption()} .
+   * Returns the head of the list, if any.
    *
    * @return The optional head of the list.
    */

From d3af2373fc02278ea76a11237b0c9d3c5fb5effa Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Tue, 6 Apr 2021 13:38:50 +1000
Subject: [PATCH 298/336] Implemented isLeft, isRight, isMiddle in terms of
 either.  Added swap methods.

---
 core/src/main/java/fj/data/Either3.java | 75 ++++++++-----------------
 1 file changed, 23 insertions(+), 52 deletions(-)

diff --git a/core/src/main/java/fj/data/Either3.java b/core/src/main/java/fj/data/Either3.java
index 8c6b7344..15b1f419 100644
--- a/core/src/main/java/fj/data/Either3.java
+++ b/core/src/main/java/fj/data/Either3.java
@@ -2,7 +2,6 @@
 
 import fj.Equal;
 import fj.F;
-import fj.F0;
 import fj.Hash;
 
 import static fj.data.Option.none;
@@ -13,53 +12,26 @@ public abstract class Either3<A, B, C> {
     private Either3() {}
 
     private static final class Left<A, B, C> extends Either3<A, B, C> {
-        A a;
+        private final A a;
+
         Left(A a) {
             this.a = a;
         }
 
-        @Override
-        public boolean isLeft() {
-            return true;
-        }
-
-        @Override
-        public boolean isMiddle() {
-            return false;
-        }
-
-        @Override
-        public boolean isRight() {
-            return false;
-        }
-
         @Override
         public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
             return fa.f(a);
         }
+
     }
 
     private static final class Middle<A, B, C> extends Either3<A, B, C> {
-        B b;
+        private final B b;
+
         Middle(B b) {
             this.b = b;
         }
 
-        @Override
-        public boolean isLeft() {
-            return false;
-        }
-
-        @Override
-        public boolean isMiddle() {
-            return true;
-        }
-
-        @Override
-        public boolean isRight() {
-            return false;
-        }
-
         @Override
         public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
             return fb.f(b);
@@ -67,26 +39,11 @@ public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
     }
 
     private static final class Right<A, B, C> extends Either3<A, B, C> {
-        C c;
+        private final C c;
         Right(C c) {
             this.c = c;
         }
 
-        @Override
-        public boolean isLeft() {
-            return false;
-        }
-
-        @Override
-        public boolean isMiddle() {
-            return false;
-        }
-
-        @Override
-        public boolean isRight() {
-            return true;
-        }
-
         @Override
         public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
             return fc.f(c);
@@ -161,11 +118,17 @@ public static <A, B, C> Either3<A, B, C> right(C c) {
         return new Right<>(c);
     }
 
-    public abstract boolean isLeft();
+    public boolean isLeft() {
+        return either(a -> true, b -> false, c -> false);
+    }
 
-    public abstract boolean isMiddle();
+    public boolean isMiddle() {
+        return either(a -> false, b -> true, c -> false);
+    }
 
-    public abstract boolean isRight();
+    public boolean isRight() {
+        return either(a -> false, b -> false, c -> true);
+    }
 
     public <X, Y, Z> Either3<X, Y, Z> map3(F<A, X> fl, F<B, Y> fm, F<C, Z> fr) {
         return either(
@@ -189,6 +152,14 @@ public Either3<C, B, A> swap() {
         return either(a -> right(a), b -> middle(b), c -> left(c));
     }
 
+    public Either3<B, A, C> swapLefts() {
+        return either(a -> middle(a), b -> left(b), c -> right(c));
+    }
+
+    public Either3<A, C, B> swapRights() {
+        return either(a -> left(a), b -> right(b), c -> middle(c));
+    }
+
     public Option<A> leftOption() {
         return either(a -> some(a), b -> none(), c -> none());
     }

From ef79720aa0afc1fd679198e652d8d478984dff75 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Wed, 7 Apr 2021 21:39:52 +1000
Subject: [PATCH 299/336] Updated inheritance of interfaces to Java 8
 interfaces

---
 core/src/main/java/fj/F0.java               |  8 +++++++-
 core/src/main/java/fj/data/IO.java          |  7 ++++++-
 core/src/main/java/fj/function/Effect0.java |  2 ++
 core/src/main/java/fj/function/Effect1.java | 20 +++++++++++++++++++-
 core/src/main/java/fj/function/Effect2.java |  8 +++++++-
 5 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/core/src/main/java/fj/F0.java b/core/src/main/java/fj/F0.java
index 14c00ca2..c260992f 100644
--- a/core/src/main/java/fj/F0.java
+++ b/core/src/main/java/fj/F0.java
@@ -1,11 +1,17 @@
 package fj;
 
+import java.util.function.Supplier;
+
 /**
  * Created by MarkPerry on 21/01/2015.
  */
 @FunctionalInterface
-public interface F0<A> {
+public interface F0<A> extends Supplier<A> {
 
     A f();
 
+    default A get() {
+        return f();
+    }
+
 }
diff --git a/core/src/main/java/fj/data/IO.java b/core/src/main/java/fj/data/IO.java
index 992abaf2..e2a94a38 100644
--- a/core/src/main/java/fj/data/IO.java
+++ b/core/src/main/java/fj/data/IO.java
@@ -6,6 +6,7 @@
 
 import fj.F;
 import fj.Unit;
+import fj.function.Try0;
 
 import java.io.IOException;
 
@@ -17,10 +18,14 @@
  * @param <A> the type of the result produced by the IO
  */
 @FunctionalInterface
-public interface IO<A> {
+public interface IO<A> extends Try0<A, IOException> {
 
 	A run() throws IOException;
 
+	default A f() throws IOException {
+		return run();
+	}
+
 	default SafeIO<Validation<IOException, A>> safe() {
 		return IOFunctions.toSafeValidation(this);
 	}
diff --git a/core/src/main/java/fj/function/Effect0.java b/core/src/main/java/fj/function/Effect0.java
index c5d4fe50..57800eb0 100644
--- a/core/src/main/java/fj/function/Effect0.java
+++ b/core/src/main/java/fj/function/Effect0.java
@@ -1,5 +1,7 @@
 package fj.function;
 
+import fj.F0;
+
 /**
  * Created by mperry on 28/08/2014.
  */
diff --git a/core/src/main/java/fj/function/Effect1.java b/core/src/main/java/fj/function/Effect1.java
index 8c89b715..0cc35a39 100644
--- a/core/src/main/java/fj/function/Effect1.java
+++ b/core/src/main/java/fj/function/Effect1.java
@@ -1,10 +1,28 @@
 package fj.function;
 
+import fj.F;
+import fj.Unit;
+
+import java.util.function.Consumer;
+
+import static fj.Unit.unit;
+
 /**
  * Created by mperry on 28/08/2014.
  */
-public interface Effect1<A> {
+public interface Effect1<A> extends Consumer<A> {
 
 	void f(A a);
 
+	default void accept(A a) {
+		f(a);
+	}
+
+	default F<A, Unit> toF() {
+		return a -> {
+			f(a);
+			return unit();
+		};
+	}
+
 }
diff --git a/core/src/main/java/fj/function/Effect2.java b/core/src/main/java/fj/function/Effect2.java
index c0735043..40d8abd8 100644
--- a/core/src/main/java/fj/function/Effect2.java
+++ b/core/src/main/java/fj/function/Effect2.java
@@ -1,10 +1,16 @@
 package fj.function;
 
+import java.util.function.BiConsumer;
+
 /**
  * Created by mperry on 28/08/2014.
  */
-public interface Effect2<A, B> {
+public interface Effect2<A, B> extends BiConsumer<A, B> {
 
 	void f(A a, B b);
 
+	default void accept(A a, B b) {
+		f(a, b);
+	}
+
 }

From 7d3f6130c4ab6cafe7fe81e5c21ceacdb8a8b375 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Wed, 7 Apr 2021 21:40:49 +1000
Subject: [PATCH 300/336] Implemented left and middle projections of Either3.

---
 core/src/main/java/fj/data/Either3.java | 286 +++++++++++++++++++++++-
 1 file changed, 279 insertions(+), 7 deletions(-)

diff --git a/core/src/main/java/fj/data/Either3.java b/core/src/main/java/fj/data/Either3.java
index 15b1f419..0c7b7371 100644
--- a/core/src/main/java/fj/data/Either3.java
+++ b/core/src/main/java/fj/data/Either3.java
@@ -1,9 +1,16 @@
 package fj.data;
 
-import fj.Equal;
-import fj.F;
-import fj.Hash;
+import fj.*;
+import fj.function.Effect1;
 
+import java.util.Collection;
+import java.util.Iterator;
+
+import static fj.Function.identity;
+import static fj.P.p;
+import static fj.Unit.unit;
+import static fj.data.Array.mkArray;
+import static fj.data.List.*;
 import static fj.data.Option.none;
 import static fj.data.Option.some;
 
@@ -49,6 +56,8 @@ public <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
             return fc.f(c);
         }
 
+
+
     }
 
     public static final class LeftProjection<A, B, C> {
@@ -62,23 +71,121 @@ public <X> Either3<X, B, C> apply(final Either3<F<A, X>, B, C> e) {
             return e.left().bind(this::map);
         }
 
-        public boolean exists(final F<A, Boolean> f) {
-            return e.either(a -> f.f(a), b -> false, c -> false);
-        }
-
         public <X> Either3<X, B, C> bind(F<A, Either3<X, B, C>> f) {
             return e.either(a -> f.f(a), b -> middle(b), c -> right(c));
         }
 
+        public Either3<A, B, C> either() {
+            return e;
+        }
+
+        public boolean exists(final F<A, Boolean> f) {
+            return e.either(a -> f.f(a), b -> false, c -> false);
+        }
+
         public <X, Y> Option<Either3<A, X, Y>> filter(final F<A, Boolean> f) {
             return e.either(a -> f.f(a) ? some(left(a)) : none(), b -> none(), c -> none());
         }
 
+        public boolean forall(final F<A, Boolean> f) {
+            return e.either(a -> f.f(a), b -> true, c -> true);
+        }
+
+        public Unit foreach(final F<A, Unit> f) {
+            return e.either(a -> f.f(a), b -> unit(), c -> unit());
+        }
+
+        public void foreachDoEffect(final Effect1<A> f) {
+            e.either(a -> f.toF().f(a), b -> unit(), c -> unit());
+        }
+
+        public Iterator<A> iterator() {
+            return toList().iterator();
+        }
 
         public <X> Either3<X, B, C> map(final F<A, X> f) {
             return e.either(a -> left(f.f(a)), b -> middle(b), c -> right(c));
         }
 
+        public A orValue(final A value) {
+            return orValue(() -> value);
+        }
+
+        public A orValue(final F0<A> f) {
+            return e.either(a -> a, b -> f.f(), c -> f.f());
+        }
+
+        public <X> Either3<X, B, C> sequence(final Either3<X, B, C> e) {
+            return bind(Function.constant(e));
+        }
+
+        public Array<A> toArray() {
+            return e.either(
+                a -> Array.single(a),
+                b -> Array.empty(),
+                c -> Array.empty()
+            );
+        }
+
+        public Collection<A> toCollection() {
+            return toList().toCollection();
+        }
+
+        public List<A> toList() {
+            return e.either(a -> single(a), b -> nil(), c -> nil());
+        }
+
+        public Option<A> toOption() {
+            return e.either(a -> some(a), b -> none(), c -> none());
+        }
+
+        public Stream<A> toStream() {
+            return e.either(a -> Stream.single(a), b -> Stream.nil(), c -> Stream.nil());
+        }
+
+        public <X> IO<Either3<X, B, C>> traverseIO(final F<A, IO<X>> f) {
+            return e.either(
+                a -> f.f(a).map(Either3::left),
+                b -> IOFunctions.unit(middle(b)),
+                c -> IOFunctions.unit(right(c))
+            );
+        }
+
+        public <X> List<Either3<X, B, C>> traverseList1(final F<A, List<X>> f) {
+            return e.either(
+                    a -> f.f(a).map(Either3::left),
+                    b -> single(middle(b)),
+                    c -> single(right(c))
+            );
+        }
+
+        public <X> Option<Either3<X, B, C>> traverseOption(final F<A, Option<X>> f) {
+            return e.either(
+                    a -> f.f(a).map(Either3::left),
+                    b -> some(middle(b)),
+                    c -> some(right(c))
+            );
+
+        }
+
+        public <X> P1<Either3<X, B, C>> traverseP1(final F<A, P1<X>> f) {
+            return e.either(
+                    a -> f.f(a).map(Either3::left),
+                    b -> p(middle(b)),
+                    c -> p(right(c))
+            );
+
+        }
+
+        public <X> Stream<Either3<X, B, C>> traverseStream(final F<A, Stream<X>> f) {
+            return e.either(
+                    a -> f.f(a).map(Either3::left),
+                    b -> Stream.single(middle(b)),
+                    c -> Stream.single(right(c))
+            );
+
+        }
+
     }
 
     public static final class MiddleProjection<A, B, C> {
@@ -88,10 +195,150 @@ private MiddleProjection(final Either3<A, B, C> e) {
             this.e = e;
         }
 
+        public <X> Either3<A, X, C> apply(final Either3<A, F<B, X>, C> e) {
+            return e.middle().bind(this::map);
+        }
+
         public <X> Either3<A, X, C> bind(F<B, Either3<A, X, C>> f) {
             return e.either(a -> left(a), b -> f.f(b), c -> right(c));
         }
 
+        public Either3<A, B, C> either() {
+            return e;
+        }
+
+        public boolean exists(final F<B, Boolean> f) {
+            return e.either(a -> false, b -> f.f(b), c -> false);
+        }
+
+        public <X, Y> Option<Either3<X, B, Y>> filter(final F<B, Boolean> f) {
+            return e.either(a -> none(), b -> f.f(b) ? some(middle(b)) : none(), c -> none());
+        }
+
+        public boolean forall(final F<B, Boolean> f) {
+            return e.either(a -> true, b -> f.f(b), c -> true);
+        }
+
+        public Unit foreach(final F<B, Unit> f) {
+            return e.either(a -> unit(), b -> f.f(b), c -> unit());
+        }
+
+        public void foreachDoEffect(final Effect1<B> f) {
+            e.either(a -> unit(), b -> f.toF().f(b), c -> unit());
+        }
+
+        public Iterator<B> iterator() {
+            return toList().iterator();
+        }
+
+        public <X> Either3<A, X, C> map(final F<B, X> f) {
+            return e.either(a -> left(a), b -> middle(f.f(b)), c -> right(c));
+        }
+
+        public B orValue(final B value) {
+            return orValue(() -> value);
+        }
+
+        public B orValue(final F0<B> f) {
+            return e.either(a -> f.f(), b -> b, c -> f.f());
+        }
+
+        public <X> Either3<A, X, C> sequence(final Either3<A, X, C> e) {
+            return bind(Function.constant(e));
+        }
+
+        public Array<B> toArray() {
+            return e.either(
+                    a -> Array.empty(),
+                    b -> Array.single(b),
+                    c -> Array.empty()
+            );
+        }
+
+        public Collection<B> toCollection() {
+            return toList().toCollection();
+        }
+
+        public List<B> toList() {
+            return e.either(a -> nil(), b -> single(b), c -> nil());
+        }
+
+        public Option<B> toOption() {
+            return e.either(a -> none(), b -> some(b), c -> none());
+        }
+
+        public Stream<B> toStream() {
+            return e.either(a -> Stream.nil(), b -> Stream.single(b), c -> Stream.nil());
+        }
+
+        public <X> IO<Either3<A, X, C>> traverseIO(final F<B, IO<X>> f) {
+            return e.either(
+                    a -> IOFunctions.unit(left(a)),
+                    b -> f.f(b).map(Either3::middle),
+                    c -> IOFunctions.unit(right(c))
+            );
+        }
+
+        public <X> List<Either3<A, X, C>> traverseList1(final F<B, List<X>> f) {
+            return e.either(
+                    a -> single(left(a)),
+                    b -> f.f(b).map(Either3::middle),
+                    c -> single(right(c))
+            );
+        }
+
+        public <X> Option<Either3<A, X, C>> traverseOption(final F<B, Option<X>> f) {
+            return e.either(
+                    a -> some(left(a)),
+                    b -> f.f(b).map(Either3::middle),
+                    c -> some(right(c))
+            );
+
+        }
+
+        public <X> P1<Either3<A, X, C>> traverseP1(final F<B, P1<X>> f) {
+            return e.either(
+                    a -> p(left(a)),
+                    b -> f.f(b).map(Either3::middle),
+                    c -> p(right(c))
+            );
+
+        }
+
+        public <X> Stream<Either3<A, X, C>> traverseStream(final F<B, Stream<X>> f) {
+            return e.either(
+                    a -> Stream.single(left(a)),
+                    b -> f.f(b).map(Either3::middle),
+                    c -> Stream.single(right(c))
+            );
+
+        }
+
+
+    }
+
+    public final <X> Either3<X, B, C> leftMap(F<A, X> f) {
+        return left().map(f);
+    }
+
+    public final <X> F<F<A, X>, Either3<X, B, C>> leftMap_() {
+        return this::leftMap;
+    }
+
+    public final <X> Either3<A, X, C> middleMap(F<B, X> f) {
+        return middle().map(f);
+    }
+
+    public final <X> F<F<B, X>, Either3<A, X, C>> middleMap_() {
+        return this::middleMap;
+    }
+
+    public final <X> Either3<A, B, X> rightMap(F<C, X> f) {
+        return right().map(f);
+    }
+
+    public final <X> F<F<C, X>, Either3<A, B, X>> rightMap_() {
+        return this::rightMap;
     }
 
     public static final class RightProjection<A, B, C> {
@@ -104,12 +351,21 @@ private RightProjection(final Either3<A, B, C> e) {
         public <X> Either3<A, B, X> bind(F<C, Either3<A, B, X>> f) {
             return e.either(a -> left(a), b -> middle(b), c -> f.f(c));
         }
+
+        public <X> Either3<A, B, X> map(final F<C, X> f) {
+            return e.either(a -> left(a), b -> middle(b), c -> right(f.f(c)));
+        }
+
     }
 
     public static <A, B, C> Either3<A, B, C> left(A a) {
         return new Left<>(a);
     }
 
+    public static <A, B, C> F<A, Either3<A, B, C>> left_() {
+        return Either3::left;
+    }
+
     public static <A, B, C> Either3<A, B, C> middle(B b) {
         return new Middle<>(b);
     }
@@ -140,6 +396,22 @@ public <X, Y, Z> Either3<X, Y, Z> map3(F<A, X> fl, F<B, Y> fm, F<C, Z> fr) {
 
     public abstract <D> D either(F<A, D> fa, F<B, D> fb, F<C, D> fc);
 
+    public static <A, B, C, D> F<Either3<A, B, C>, D> either_(F<A, D> fa, F<B, D> fb, F<C, D> fc) {
+        return e -> e.either(fa, fb, fc);
+    }
+
+    public static <A, B, C> Either3<A, B, C> joinLeft(final Either3<Either3<A, B, C>, B, C> e) {
+        return e.left().bind(identity());
+    }
+
+    public static <A, B, C> Either3<A, B, C> joinMiddle(final Either3<A, Either3<A, B, C>, C> e) {
+        return e.middle().bind(identity());
+    }
+
+    public static <A, B, C> Either3<A, B, C> joinRight(final Either3<A, B, Either3<A, B, C>> e) {
+        return e.right().bind(identity());
+    }
+
     public Either3<B, C, A> moveLeft() {
         return either(a -> right(a), b -> left(b), c -> middle(c));
     }

From eedacf0010d8db853fd18c5ba59384d7740f9a9c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Wed, 7 Apr 2021 21:53:53 +1000
Subject: [PATCH 301/336] Implemented the right projection of Either3.

---
 core/src/main/java/fj/data/Either3.java | 111 ++++++++++++++++++++++++
 1 file changed, 111 insertions(+)

diff --git a/core/src/main/java/fj/data/Either3.java b/core/src/main/java/fj/data/Either3.java
index 0c7b7371..9b545f7e 100644
--- a/core/src/main/java/fj/data/Either3.java
+++ b/core/src/main/java/fj/data/Either3.java
@@ -347,15 +347,126 @@ public static final class RightProjection<A, B, C> {
         private RightProjection(final Either3<A, B, C> e) {
             this.e = e;
         }
+        public <X> Either3<A, B, X> apply(final Either3<A, B, F<C, X>> e) {
+            return e.right().bind(this::map);
+        }
 
         public <X> Either3<A, B, X> bind(F<C, Either3<A, B, X>> f) {
             return e.either(a -> left(a), b -> middle(b), c -> f.f(c));
         }
 
+        public Either3<A, B, C> either() {
+            return e;
+        }
+
+        public boolean exists(final F<C, Boolean> f) {
+            return e.either(a -> false, b -> false, c -> f.f(c));
+        }
+
+        public <X, Y> Option<Either3<X, Y, C>> filter(final F<C, Boolean> f) {
+            return e.either(a -> none(), b -> none(), c -> f.f(c) ? some(right(c)) : none());
+        }
+
+        public boolean forall(final F<C, Boolean> f) {
+            return e.either(a -> true, b -> true, c -> f.f(c));
+        }
+
+        public Unit foreach(final F<C, Unit> f) {
+            return e.either(a -> unit(), b -> unit(), c -> f.f(c));
+        }
+
+        public void foreachDoEffect(final Effect1<C> f) {
+            e.either(a -> unit(), b -> unit(), c -> f.toF().f(c));
+        }
+
+        public Iterator<C> iterator() {
+            return toList().iterator();
+        }
+
         public <X> Either3<A, B, X> map(final F<C, X> f) {
             return e.either(a -> left(a), b -> middle(b), c -> right(f.f(c)));
         }
 
+        public C orValue(final C value) {
+            return orValue(() -> value);
+        }
+
+        public C orValue(final F0<C> f) {
+            return e.either(a -> f.f(), b -> f.f(), c -> c);
+        }
+
+        public <X> Either3<A, B, X> sequence(final Either3<A, B, X> e) {
+            return bind(Function.constant(e));
+        }
+
+        public Array<C> toArray() {
+            return e.either(
+                    a -> Array.empty(),
+                    b -> Array.empty(),
+                    c -> Array.single(c)
+            );
+        }
+
+        public Collection<C> toCollection() {
+            return toList().toCollection();
+        }
+
+        public List<C> toList() {
+            return e.either(a -> nil(), b -> nil(), c -> single(c));
+        }
+
+        public Option<C> toOption() {
+            return e.either(a -> none(), b -> none(), c -> some(c));
+        }
+
+        public Stream<C> toStream() {
+            return e.either(a -> Stream.nil(), b -> Stream.nil(), c -> Stream.single(c));
+        }
+
+        public <X> IO<Either3<A, B, X>> traverseIO(final F<C, IO<X>> f) {
+            return e.either(
+                    a -> IOFunctions.unit(left(a)),
+                    b -> IOFunctions.unit(middle(b)),
+                    c -> f.f(c).map(Either3::right)
+            );
+        }
+
+        public <X> List<Either3<A, B, X>> traverseList1(final F<C, List<X>> f) {
+            return e.either(
+                    a -> single(left(a)),
+                    b -> single(middle(b)),
+                    c -> f.f(c).map(Either3::right)
+            );
+        }
+
+        public <X> Option<Either3<A, B, X>> traverseOption(final F<C, Option<X>> f) {
+            return e.either(
+                    a -> some(left(a)),
+                    b -> some(middle(b)),
+                    c -> f.f(c).map(Either3::right)
+            );
+
+        }
+
+        public <X> P1<Either3<A, B, X>> traverseP1(final F<C, P1<X>> f) {
+            return e.either(
+                    a -> p(left(a)),
+                    b -> p(middle(b)),
+                    c -> f.f(c).map(Either3::right)
+            );
+
+        }
+
+        public <X> Stream<Either3<A, B, X>> traverseStream(final F<C, Stream<X>> f) {
+            return e.either(
+                    a -> Stream.single(left(a)),
+                    b -> Stream.single(middle(b)),
+                    c -> f.f(c).map(Either3::right)
+            );
+
+        }
+
+
     }
 
     public static <A, B, C> Either3<A, B, C> left(A a) {

From 546647277325db569386141681eefc99a889ec25 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 16 Apr 2021 22:39:20 +1000
Subject: [PATCH 302/336] Speed up Gradle tests by not generating test reports
 and running in parallel.

---
 build.gradle      | 10 ++++++++++
 gradle.properties |  3 +++
 2 files changed, 13 insertions(+)

diff --git a/build.gradle b/build.gradle
index 57c36c18..8e390f9c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -70,6 +70,7 @@ allprojects {
         junitRuntime = "org.junit.vintage:junit-vintage-engine:5.5.2"
 
         displayCompilerWarnings = true
+        generateTestReports = false
     }
 
     repositories {
@@ -112,6 +113,15 @@ subprojects {
        }
     }
 
+    tasks.withType(Test).configureEach {
+        maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
+        if (!generateTestReports) {
+            reports.html.enabled = false
+            reports.junitXml.enabled = false
+        }
+    }
+
+
 }
 
 task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
diff --git a/gradle.properties b/gradle.properties
index d4552a30..8f904ddb 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -3,3 +3,6 @@ sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
 signingEnabled = false
+
+org.gradle.parallel = true
+

From 8cef774bf2fbd850bf0a5e13bb76d2fab8380ade Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 16 Apr 2021 22:44:17 +1000
Subject: [PATCH 303/336] Renamed show for Either3.

---
 core/src/main/java/fj/Show.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index 62da5273..bfb2e151 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -256,7 +256,7 @@ public static <A, B> Show<Either<A, B>> eitherShow(final Show<A> sa, final Show<
            fromString("Right(").append(sb.f.f(e.right().value())).append(single(')')));
   }
 
-  public static <A, B, C> Show<Either3<A, B, C>> eitherShow(final Show<A> sa, final Show<B> sb, final Show<C> sc) {
+  public static <A, B, C> Show<Either3<A, B, C>> either3Show(final Show<A> sa, final Show<B> sb, final Show<C> sc) {
     return show(e ->
       e.either(
         a -> fromString("Left(").append(sa.f.f(a)).append(single(')')),

From 250aa82edd48edca4a315ee27f89cfc1bbb88e5b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 18 Apr 2021 21:54:27 +1000
Subject: [PATCH 304/336] Make SafeIO inherit of F0.

---
 core/src/main/java/fj/data/SafeIO.java | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index 11fdc31a..0643e886 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -1,13 +1,20 @@
 package fj.data;
 
+import fj.F0;
+
 /**
  * Created by MarkPerry on 3/07/2014.
  */
 @FunctionalInterface
-public interface SafeIO<A> extends IO<A> {
+public interface SafeIO<A> extends IO<A>, F0<A> {
 
 	@Override
 	A run();
 
+	@Override
+	default A f() {
+		return run();
+	}
+
 }
 

From 2cad57e8c28f3f61dc929adf1387b0a48a1c354b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 18 Apr 2021 21:56:05 +1000
Subject: [PATCH 305/336] Added conversions from Effect0 to Try, TryEffect and
 F0.

---
 core/src/main/java/fj/function/Effect0.java | 29 ++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/function/Effect0.java b/core/src/main/java/fj/function/Effect0.java
index 57800eb0..5e499d2d 100644
--- a/core/src/main/java/fj/function/Effect0.java
+++ b/core/src/main/java/fj/function/Effect0.java
@@ -1,6 +1,8 @@
 package fj.function;
 
-import fj.F0;
+import fj.*;
+
+import static fj.Unit.unit;
 
 /**
  * Created by mperry on 28/08/2014.
@@ -9,4 +11,29 @@ public interface Effect0 {
 
 	void f();
 
+	default F0<Unit> toF0() {
+		return () -> {
+			f();
+			return unit();
+		};
+	}
+
+	default <E extends Exception> TryEffect0<E> toTryEffect0() {
+		return () -> f();
+	}
+
+	default <E extends Exception> Try0<Unit, E> toTry0() {
+		return () -> {
+			f();
+			return unit();
+		};
+	}
+
+	default P1<Unit> toP1() {
+		return P.lazy(() -> {
+			f();
+			return unit();
+		});
+	}
+
 }

From 0f4f8548635e74c4fb9582887ad15c51acb1601f Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 18 Apr 2021 22:51:23 +1000
Subject: [PATCH 306/336] Implemented primary functions from F in Effect1.

---
 core/src/main/java/fj/function/Effect1.java | 40 +++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/core/src/main/java/fj/function/Effect1.java b/core/src/main/java/fj/function/Effect1.java
index 0cc35a39..64abed44 100644
--- a/core/src/main/java/fj/function/Effect1.java
+++ b/core/src/main/java/fj/function/Effect1.java
@@ -1,6 +1,8 @@
 package fj.function;
 
 import fj.F;
+import fj.P;
+import fj.P1;
 import fj.Unit;
 
 import java.util.function.Consumer;
@@ -18,6 +20,32 @@ default void accept(A a) {
 		f(a);
 	}
 
+	default <C> F<A, C> bind(final F<Unit, F<A, C>> g) {
+		return a -> {
+			return g.f(toF().f(a)).f(a);
+		};
+	}
+
+	default void apply(A a) {
+		f(a);
+	}
+
+	default <C> Effect1<C> contramap(F<C, A> f) {
+		return o(f);
+	}
+
+	default <C> F<A, C> map(F<Unit, C> f) {
+		return a -> f.f(toF().f(a));
+	}
+
+	default <B> F<A, B> andThen(final F<Unit, B> f) {
+		return map(f);
+	}
+
+	default <C> Effect1<C> o(final F<C, A> f) {
+		return c -> f(f.f(c));
+	}
+
 	default F<A, Unit> toF() {
 		return a -> {
 			f(a);
@@ -25,4 +53,16 @@ default F<A, Unit> toF() {
 		};
 	}
 
+	static <A> Effect1<A> fromF(F<A, Unit> f) {
+		return a -> f.f(a);
+	}
+
+	default <C, D> F<C, D> dimap(F<C, A> f, F<Unit, D> g) {
+		return c -> g.f(toF().f(f.f(c)));
+	}
+
+	default P1<Unit> partial(final A a) {
+		return P.lazy(() -> toF().f(a));
+	}
+
 }

From 53ab41a58021a17a109772918c9c02f08ed32f8f Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 19 Apr 2021 00:40:18 +1000
Subject: [PATCH 307/336] Added conversion functions between Effect, F, Try and
 TryEffect for low arities.

---
 core/src/main/java/fj/F0.java                 | 20 ++++++++
 core/src/main/java/fj/data/SafeIO.java        |  6 ++-
 core/src/main/java/fj/function/Effect1.java   | 11 ++++
 core/src/main/java/fj/function/Effect2.java   | 12 +++++
 core/src/main/java/fj/function/Try0.java      | 37 ++++++++++++++
 .../src/main/java/fj/function/TryEffect0.java | 50 +++++++++++++++++++
 6 files changed, 135 insertions(+), 1 deletion(-)

diff --git a/core/src/main/java/fj/F0.java b/core/src/main/java/fj/F0.java
index c260992f..9354568c 100644
--- a/core/src/main/java/fj/F0.java
+++ b/core/src/main/java/fj/F0.java
@@ -1,5 +1,9 @@
 package fj;
 
+import fj.function.Effect0;
+import fj.function.Try0;
+import fj.function.TryEffect0;
+
 import java.util.function.Supplier;
 
 /**
@@ -14,4 +18,20 @@ default A get() {
         return f();
     }
 
+    default Effect0 toEffect0() {
+        return () -> f();
+    }
+
+    default <Z extends Exception> TryEffect0<Z> toTryEffect0() {
+        return () -> f();
+    }
+
+    default <Z extends Exception> Try0<A, Z> toTry0() {
+        return () -> f();
+    }
+
+    default P1<A> toP1() {
+        return P.lazy(() -> f());
+    }
+
 }
diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index 0643e886..eeef79f9 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -1,12 +1,16 @@
 package fj.data;
 
 import fj.F0;
+import fj.P;
+import fj.P1;
+
+import java.io.IOException;
 
 /**
  * Created by MarkPerry on 3/07/2014.
  */
 @FunctionalInterface
-public interface SafeIO<A> extends IO<A>, F0<A> {
+public interface SafeIO<A> extends IO<A> {
 
 	@Override
 	A run();
diff --git a/core/src/main/java/fj/function/Effect1.java b/core/src/main/java/fj/function/Effect1.java
index 64abed44..aff85774 100644
--- a/core/src/main/java/fj/function/Effect1.java
+++ b/core/src/main/java/fj/function/Effect1.java
@@ -53,6 +53,15 @@ default F<A, Unit> toF() {
 		};
 	}
 
+	default <Z extends Exception> TryEffect1<A, Z> toTryEffect1() {
+		return a -> f(a);
+	}
+
+
+	default <Z extends Exception> Try1<A, Unit, Z> toTry1() {
+		return a -> toF().f(a);
+	}
+
 	static <A> Effect1<A> fromF(F<A, Unit> f) {
 		return a -> f.f(a);
 	}
@@ -65,4 +74,6 @@ default P1<Unit> partial(final A a) {
 		return P.lazy(() -> toF().f(a));
 	}
 
+
+
 }
diff --git a/core/src/main/java/fj/function/Effect2.java b/core/src/main/java/fj/function/Effect2.java
index 40d8abd8..e4d7701a 100644
--- a/core/src/main/java/fj/function/Effect2.java
+++ b/core/src/main/java/fj/function/Effect2.java
@@ -1,7 +1,12 @@
 package fj.function;
 
+import fj.F2;
+import fj.Unit;
+
 import java.util.function.BiConsumer;
 
+import static fj.Unit.unit;
+
 /**
  * Created by mperry on 28/08/2014.
  */
@@ -13,4 +18,11 @@ default void accept(A a, B b) {
 		f(a, b);
 	}
 
+	default F2<A, B, Unit> toF2() {
+		return (a, b) -> {
+			f(a, b);
+			return unit();
+		};
+	}
+
 }
diff --git a/core/src/main/java/fj/function/Try0.java b/core/src/main/java/fj/function/Try0.java
index e218f0a7..9abfa6cd 100644
--- a/core/src/main/java/fj/function/Try0.java
+++ b/core/src/main/java/fj/function/Try0.java
@@ -1,5 +1,14 @@
 package fj.function;
 
+import fj.F0;
+import fj.P;
+import fj.P1;
+import fj.data.Option;
+import fj.data.Validation;
+
+import static fj.data.Validation.fail;
+import static fj.data.Validation.success;
+
 /**
  * A product of <code>A</code> which may throw an <code>Exception</code>.
  *
@@ -13,4 +22,32 @@ public interface Try0<A, Z extends Exception> {
 
     A f() throws Z;
 
+    @SuppressWarnings("unchecked")
+    default F0<Validation<Z, A>> toF0() {
+        return () -> {
+            try {
+                return success(f());
+            } catch (Exception e) {
+                return fail((Z) e);
+            }
+        };
+    }
+
+    default TryEffect0<Z> toTryEffect0() {
+        return () -> f();
+    }
+
+    default Effect0 toEffect0() {
+        return () -> {
+            try {
+                f();
+            } catch (Exception e) {
+            }
+        };
+    }
+
+    default P1<Validation<Z, A>> toP1() {
+        return P.lazy(() -> toF0().f());
+    }
+
 }
diff --git a/core/src/main/java/fj/function/TryEffect0.java b/core/src/main/java/fj/function/TryEffect0.java
index a6c9cbee..9a955c89 100644
--- a/core/src/main/java/fj/function/TryEffect0.java
+++ b/core/src/main/java/fj/function/TryEffect0.java
@@ -1,5 +1,15 @@
 package fj.function;
 
+import fj.F0;
+import fj.P;
+import fj.P1;
+import fj.Unit;
+import fj.data.Option;
+
+import static fj.Unit.unit;
+import static fj.data.Option.none;
+import static fj.data.Option.some;
+
 /**
  * Created by mperry on 28/08/2014.
  */
@@ -7,4 +17,44 @@ public interface TryEffect0<Z extends Exception> {
 
 	void f() throws Z;
 
+	@SuppressWarnings("unchecked")
+	default F0<Option<Z>> toF0() {
+		return () -> {
+			try {
+				f();
+				return none();
+			} catch (Exception e) {
+				return some((Z) e);
+			}
+		};
+	}
+
+	@SuppressWarnings("unchecked")
+	default Try0<Unit, Z> toTry0() {
+		return () -> {
+			try {
+				f();
+				return unit();
+			} catch (Exception e) {
+				throw ((Z) e);
+			}
+		};
+	}
+
+	default Effect0 toEffect0() {
+		return () -> {
+			try {
+				f();
+			} catch (Exception e) {
+			}
+		};
+	}
+
+	default P1<Unit> toP1() {
+		return P.lazy(() -> {
+			toEffect0().f();
+			return Unit.unit();
+		});
+	}
+
 }

From 19a70d92b43dfea29ae219a994230562d9375708 Mon Sep 17 00:00:00 2001
From: Chen Zhang <340355960@qq.com>
Date: Tue, 17 Aug 2021 10:09:52 +0800
Subject: [PATCH 308/336] Improve Travis CI build Performance

---
 .travis.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 8e7c52c9..89680bd8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,6 +9,7 @@ jdk:
  - openjdk-ea
 
 matrix:
+  fast_finish: true
 
   include:
   - jdk: openjdk12
@@ -31,3 +32,8 @@ env:
   global:
     - secure: Bun+1FZ29Q3dR9gZ/5brxcSf+zcY5tWrsqOA4GUb5bYCMyORuXQB0FYXuhKR4wB1pFrk1a9EYwRwSu3GwRJVWb+UzF0CNOWF/QG5tGPx32IOXScwlL/KonI4Vhs7Oc0fF4Wdb7euNrT27BU61jbUugjJ642b3n0VBYFYDdquprU=
     - secure: QAxhjqLRa+WHKIzgIJPZ/rM5a5uzqG7E5rsC0YvB25cO712oYXmzsYPia/oSp0chXlYLYMfk2UnLeQCSx2e6ogXRRRa977Q+B33Nt0Hd9SGLtduv6DBrbA2ehLU12Ib4DWe5VhF5eueAunycYcllTvqA5h+pzTtEVbd68ZHncM4=
+
+cache:
+  directories:
+  - $HOME/.gradle/caches/
+  - $HOME/.gradle/wrapper/

From da4cd6264e102c96d2c78eba56fa57af12655d08 Mon Sep 17 00:00:00 2001
From: YunLemon <340355960@qq.com>
Date: Wed, 18 Aug 2021 08:23:20 +0800
Subject: [PATCH 309/336] Update .travis.yml

---
 .travis.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 89680bd8..a7465305 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -27,7 +27,6 @@ matrix:
 script:
   - ./gradlew clean test
 
-
 env:
   global:
     - secure: Bun+1FZ29Q3dR9gZ/5brxcSf+zcY5tWrsqOA4GUb5bYCMyORuXQB0FYXuhKR4wB1pFrk1a9EYwRwSu3GwRJVWb+UzF0CNOWF/QG5tGPx32IOXScwlL/KonI4Vhs7Oc0fF4Wdb7euNrT27BU61jbUugjJ642b3n0VBYFYDdquprU=

From 20f6248c8a7ac7a8e0cedece07aca6b6de4306e1 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Wed, 9 Feb 2022 22:28:28 +1000
Subject: [PATCH 310/336] Set the default to signing disabled as per the 5.x
 branch

---
 gradle.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle.properties b/gradle.properties
index 07c2b60c..d4552a30 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,4 +2,4 @@
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = true
+signingEnabled = false

From 2387c3d3e8ff9c7899eda5e85365737477636edb Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 10 Feb 2022 20:34:40 +1000
Subject: [PATCH 311/336] Removed Java 9 options so the 5.x branch works with
 Java 8

---
 build.gradle | 2 --
 1 file changed, 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 8e390f9c..81d2c1f1 100644
--- a/build.gradle
+++ b/build.gradle
@@ -107,7 +107,6 @@ subprojects {
 	}
 
     tasks.withType(JavaCompile) {
-        options.compilerArgs.addAll(['--release', '8'])
         if (displayCompilerWarnings) {
 			options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
        }
@@ -146,7 +145,6 @@ configure(subprojects.findAll { it.name != "props-core" }) {
     sourceCompatibility = "1.8"
 
     javadoc {
-        options.addBooleanOption('html5', true)
     }
 
     task javadocJar(type: Jar, dependsOn: "javadoc") {

From baf69e9c359f8ee909b50fcddd0ed3b4eab438ce Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 10 Feb 2022 20:54:43 +1000
Subject: [PATCH 312/336] Template for version 5.0 release notes

---
 etc/release-notes/release-notes-5.0.adoc | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 etc/release-notes/release-notes-5.0.adoc

diff --git a/etc/release-notes/release-notes-5.0.adoc b/etc/release-notes/release-notes-5.0.adoc
new file mode 100644
index 00000000..89138acd
--- /dev/null
+++ b/etc/release-notes/release-notes-5.0.adoc
@@ -0,0 +1,22 @@
+
+= Release 5.0
+
+Released: TODO
+
+== Enhancements
+
+== Fixes
+
+
+== Internal
+
+
+== Breaking Changes
+
+
+== Documentation
+
+
+
+== Contributors
+

From ed841cd150b552d11234baecbbd87adf5db135ed Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 10 Feb 2022 23:26:45 +1000
Subject: [PATCH 313/336] Added FJ 5.0 doc release notes

---
 etc/release-notes/release-notes-5.0.adoc | 37 ++++++++++++++++++++----
 1 file changed, 32 insertions(+), 5 deletions(-)

diff --git a/etc/release-notes/release-notes-5.0.adoc b/etc/release-notes/release-notes-5.0.adoc
index 89138acd..86cfc69e 100644
--- a/etc/release-notes/release-notes-5.0.adoc
+++ b/etc/release-notes/release-notes-5.0.adoc
@@ -4,19 +4,46 @@
 Released: TODO
 
 == Enhancements
+* The functions classes F, F2, F0, Effect1 and Effect2 extend the corresponding Java 8 function interface.  Removed the corresponding classes F1W, F1Functions, F2W and F2Functions.  Similarly for IO and IOW.
+* Moved the function wrapper classes F1W and F2W into F and F2 as default functions.
+* Added lifting a semigroup to an option monoid, using none as zero.
+* Added Trampoline.suspend(F0<Trampoline<A>>)
+* Added sum, product and fromString to Longs.
+* Added Bounded definition.
+* Added toStream of Bounded in Enumerator.
+* Added intersection monoid for sets.
+* Added set intersection semigroup.
+* Added FunctionalInterface annotations for interfaces F0, F, F2 to F8, IO and SafeIO.
+* Added functions to IO.
+* Added Either3.
+* Updated IO and SafeIO inheritance.
+* Added conversion functions for Effect, F, Try and TryEffect for low arities.
 
 == Fixes
-
+* Fixed BitSet properties test.
 
 == Internal
-
+* Upgraded to Gradle 6.8.3.
+* Added Strategy, Validation, Integers, monoid, semigroup and monoid tests.
+* Switch from the uptodate-gradle-plugin to gradle-versions-plugin.
+* Speed up Gradle tests by running in parallel and not generating reports.
 
 == Breaking Changes
-
+* Removed Ord parameter from Monoid's setIntersectionMonoid function.
+* Removed the classes F1W, F1Functions, F2W, F2Functions, F3W, F3Functions, F4W, F4Functions, F5W, F5Functions, F6W, F6Functions, F7W, F7Functions, F8W and F8Functions.
+* Removed deprecated Monoid, Ord, P, P1, Semigroup, Array, HashMap, Java, List, Seq, Set, Stream, Gen, Rand and TreeMap functions.
 
 == Documentation
-
-
+* Fixed the javadoc on Either's iif function.
+* Fixed doc for union and intersection monoid for sets.
+* Fixed semigroup docs.
+* Fixed List.headOption.
 
 == Contributors
+* Gabor Liptak
+* Jean-Baptiste Giraudeau
+* Soundharya Kamaraj
+* Yaroslav Atroshenko
+* Mark Perry
+* Chen Zhang
 

From f7a29a5be2df6dad22e4606a246e9b586d28f64b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 00:09:54 +1000
Subject: [PATCH 314/336] Removed build.number in the javadoc and created by
 Mark Perry

---
 build.gradle                                           |  2 +-
 consume/src/test/java/fj/EmptyTest.java                |  3 ---
 core/src/main/java/fj/Bottom.java                      |  2 --
 core/src/main/java/fj/Class.java                       |  2 --
 core/src/main/java/fj/Digit.java                       |  2 --
 core/src/main/java/fj/Effect.java                      |  2 --
 core/src/main/java/fj/Equal.java                       |  2 --
 core/src/main/java/fj/F.java                           |  5 +----
 core/src/main/java/fj/F0.java                          |  3 ---
 core/src/main/java/fj/F2.java                          |  3 ---
 core/src/main/java/fj/F3.java                          |  4 +---
 core/src/main/java/fj/F4.java                          |  4 +---
 core/src/main/java/fj/F5.java                          |  5 +----
 core/src/main/java/fj/F6.java                          |  5 +----
 core/src/main/java/fj/F7.java                          |  5 +----
 core/src/main/java/fj/F8.java                          |  4 +---
 core/src/main/java/fj/Function.java                    |  2 --
 core/src/main/java/fj/Hash.java                        |  2 --
 core/src/main/java/fj/LcgRng.java                      |  2 --
 core/src/main/java/fj/Monoid.java                      |  2 --
 core/src/main/java/fj/Ord.java                         |  2 --
 core/src/main/java/fj/Ordering.java                    |  2 --
 core/src/main/java/fj/P.java                           |  2 --
 core/src/main/java/fj/P1.java                          | 10 +---------
 core/src/main/java/fj/P2.java                          |  2 --
 core/src/main/java/fj/P3.java                          |  2 --
 core/src/main/java/fj/P4.java                          |  2 --
 core/src/main/java/fj/P5.java                          |  2 --
 core/src/main/java/fj/P6.java                          |  2 --
 core/src/main/java/fj/P7.java                          |  2 --
 core/src/main/java/fj/P8.java                          |  2 --
 core/src/main/java/fj/Primitive.java                   |  2 --
 core/src/main/java/fj/Rng.java                         |  3 ---
 core/src/main/java/fj/Semigroup.java                   |  2 --
 core/src/main/java/fj/Show.java                        |  2 --
 core/src/main/java/fj/Try.java                         |  3 ---
 core/src/main/java/fj/TryEffect.java                   |  3 ---
 core/src/main/java/fj/Unit.java                        |  2 --
 core/src/main/java/fj/control/Trampoline.java          |  2 +-
 core/src/main/java/fj/data/IO.java                     |  4 ----
 core/src/main/java/fj/data/Iteratee.java               |  3 ---
 core/src/main/java/fj/data/Java.java                   |  2 --
 core/src/main/java/fj/data/Java8.java                  |  3 ---
 core/src/main/java/fj/data/List.java                   |  2 --
 core/src/main/java/fj/data/NonEmptyList.java           |  2 --
 core/src/main/java/fj/data/Option.java                 |  2 --
 core/src/main/java/fj/data/PriorityQueue.java          |  2 --
 core/src/main/java/fj/data/Reader.java                 |  1 -
 core/src/main/java/fj/data/SafeIO.java                 |  9 ---------
 core/src/main/java/fj/data/State.java                  |  3 ---
 core/src/main/java/fj/data/Stream.java                 |  2 --
 core/src/main/java/fj/data/Tree.java                   |  2 --
 core/src/main/java/fj/data/Validation.java             |  2 --
 core/src/main/java/fj/data/Writer.java                 |  3 ---
 core/src/main/java/fj/data/hamt/BitSet.java            |  2 --
 .../main/java/fj/data/hamt/HashArrayMappedTrie.java    |  2 --
 core/src/main/java/fj/data/hamt/Node.java              |  2 --
 core/src/main/java/fj/data/package-info.java           |  2 --
 core/src/main/java/fj/function/BigIntegers.java        |  2 --
 core/src/main/java/fj/function/Booleans.java           |  2 --
 core/src/main/java/fj/function/Doubles.java            |  2 --
 core/src/main/java/fj/function/Effect0.java            |  3 ---
 core/src/main/java/fj/function/Effect1.java            |  3 ---
 core/src/main/java/fj/function/Effect2.java            |  3 ---
 core/src/main/java/fj/function/Effect3.java            |  3 ---
 core/src/main/java/fj/function/Effect4.java            |  3 ---
 core/src/main/java/fj/function/Effect5.java            |  3 ---
 core/src/main/java/fj/function/Effect6.java            |  3 ---
 core/src/main/java/fj/function/Effect7.java            |  3 ---
 core/src/main/java/fj/function/Effect8.java            |  3 ---
 core/src/main/java/fj/function/Integers.java           |  2 --
 core/src/main/java/fj/function/Longs.java              |  2 --
 core/src/main/java/fj/function/Strings.java            |  2 --
 core/src/main/java/fj/function/Try0.java               |  1 -
 core/src/main/java/fj/function/Try1.java               |  1 -
 core/src/main/java/fj/function/Try2.java               |  1 -
 core/src/main/java/fj/function/Try3.java               |  1 -
 core/src/main/java/fj/function/Try4.java               |  1 -
 core/src/main/java/fj/function/Try5.java               |  1 -
 core/src/main/java/fj/function/Try6.java               |  1 -
 core/src/main/java/fj/function/Try7.java               |  1 -
 core/src/main/java/fj/function/Try8.java               |  1 -
 core/src/main/java/fj/function/TryEffect0.java         |  3 ---
 core/src/main/java/fj/function/TryEffect1.java         |  3 ---
 core/src/main/java/fj/function/TryEffect2.java         |  3 ---
 core/src/main/java/fj/function/TryEffect3.java         |  3 ---
 core/src/main/java/fj/function/TryEffect4.java         |  3 ---
 core/src/main/java/fj/function/TryEffect5.java         |  3 ---
 core/src/main/java/fj/function/TryEffect6.java         |  3 ---
 core/src/main/java/fj/function/TryEffect7.java         |  3 ---
 core/src/main/java/fj/function/TryEffect8.java         |  3 ---
 core/src/main/java/fj/function/Visitor.java            |  2 --
 core/src/main/java/fj/function/package-info.java       |  2 --
 core/src/main/java/fj/package-info.java                |  2 --
 core/src/main/java/fj/parser/Parser.java               |  2 --
 core/src/main/java/fj/parser/Result.java               |  2 --
 core/src/main/java/fj/parser/package-info.java         |  2 --
 core/src/test/java/fj/P2Test.java                      |  3 ---
 core/src/test/java/fj/ShowTest.java                    |  3 ---
 core/src/test/java/fj/data/ArrayTest.java              |  3 ---
 core/src/test/java/fj/data/BooleansTest.java           |  3 ---
 core/src/test/java/fj/data/JavaTest.java               |  3 ---
 core/src/test/java/fj/data/LazyStringTest.java         |  3 ---
 core/src/test/java/fj/data/ListBufferTest.java         |  3 ---
 core/src/test/java/fj/data/ListTest.java               |  3 ---
 core/src/test/java/fj/data/List_Traverse_Tests.java    |  3 ---
 core/src/test/java/fj/data/OptionTest.java             |  3 ---
 core/src/test/java/fj/data/SeqTest.java                |  3 ---
 core/src/test/java/fj/data/SetTest.java                |  3 ---
 core/src/test/java/fj/data/StateTest.java              |  3 ---
 core/src/test/java/fj/data/StreamTest.java             |  3 ---
 core/src/test/java/fj/data/TreeMapTest.java            |  3 ---
 core/src/test/java/fj/data/TreeTest.java               |  6 +-----
 core/src/test/java/fj/data/UnitTest.java               |  3 ---
 core/src/test/java/fj/function/TestEffect.java         |  4 ----
 demo/src/main/java/fj/demo/IODemo.java                 |  3 ---
 demo/src/main/java/fj/demo/StateDemo_Greeter.java      |  3 ---
 .../main/java/fj/demo/StateDemo_VendingMachine.java    |  3 ---
 demo/src/main/java/fj/demo/WriterDemo_Halver.java      |  3 ---
 demo/src/main/java/fj/demo/optic/LensPerson.java       |  3 ---
 demo/src/main/java/fj/demo/realworld/Chapter7.java     |  2 --
 demo/src/test/java/fj/EmptyTest.java                   |  3 ---
 java-core/src/main/java/fj/java/util/ListUtil.java     |  3 ---
 java-core/src/test/java/fj/EmptyTest.java              |  3 ---
 .../src/main/java/fj/data/dummy/DummyClass.java        |  3 ---
 performance/src/test/java/fj/data/dummy/DummyTest.java |  3 ---
 props-core/src/test/java/fj/MemoisationTest.java       |  3 ---
 props-core/src/test/java/fj/data/ReaderTest.java       |  3 ---
 props-core/src/test/java/fj/data/TestRngState.java     |  3 ---
 props-core/src/test/java/fj/data/WriterTest.java       |  3 ---
 .../java/fj/data/fingertrees/FingerTreeProperties.java |  4 ----
 .../test/java/fj/data/fingertrees/FingerTreeTest.java  |  4 ----
 .../src/test/java/fj/data/hamt/BitSetProperties.java   |  4 ----
 .../fj/data/properties/NonEmptyListProperties.java     |  3 ---
 .../fj/data/properties/PriorityQueueProperties.java    |  3 ---
 .../test/java/fj/data/properties/SetProperties.java    |  3 ---
 .../java/fj/data/properties/TreeMapProperties.java     |  3 ---
 .../java/fj/data/properties/ValidationProperties.java  |  3 ---
 .../src/main/java/fj/data/test/PropertyAssert.java     |  3 ---
 quickcheck/src/test/java/fj/data/test/TestNull.java    |  3 ---
 quickcheck/src/test/java/fj/test/TestRand.java         |  3 ---
 141 files changed, 11 insertions(+), 374 deletions(-)

diff --git a/build.gradle b/build.gradle
index 81d2c1f1..1ceb4fb9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -46,7 +46,7 @@ allprojects {
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.8.1"
+        fjConsumeVersion = "4.9"
 
         signModule = false
 
diff --git a/consume/src/test/java/fj/EmptyTest.java b/consume/src/test/java/fj/EmptyTest.java
index e112a97a..13675822 100644
--- a/consume/src/test/java/fj/EmptyTest.java
+++ b/consume/src/test/java/fj/EmptyTest.java
@@ -5,9 +5,6 @@
 
 import org.junit.Assert;
 
-/**
- * Created by MarkPerry on 30/08/2015.
- */
 public class EmptyTest {
 
     @Ignore @Test
diff --git a/core/src/main/java/fj/Bottom.java b/core/src/main/java/fj/Bottom.java
index a70629f1..5cc7f4e4 100644
--- a/core/src/main/java/fj/Bottom.java
+++ b/core/src/main/java/fj/Bottom.java
@@ -2,8 +2,6 @@
 
 /**
  * Represents the bottom _|_ value.
- *
- * @version %build.number%
  */
 public final class Bottom {
   private Bottom() {
diff --git a/core/src/main/java/fj/Class.java b/core/src/main/java/fj/Class.java
index 56222de1..8bee1951 100644
--- a/core/src/main/java/fj/Class.java
+++ b/core/src/main/java/fj/Class.java
@@ -11,8 +11,6 @@
 
 /**
  * A wrapper for a {@link java.lang.Class} that provides additional methods.
- *
- * @version %build.number%
  */
 public final class Class<T> {
   private final java.lang.Class<T> c;
diff --git a/core/src/main/java/fj/Digit.java b/core/src/main/java/fj/Digit.java
index 7213e278..4fec7b0c 100644
--- a/core/src/main/java/fj/Digit.java
+++ b/core/src/main/java/fj/Digit.java
@@ -6,8 +6,6 @@
 
 /**
  * The digits zero to nine.
- *
- * @version %build.number%
  */
 public enum Digit {
   /**
diff --git a/core/src/main/java/fj/Effect.java b/core/src/main/java/fj/Effect.java
index 80680cac..2b5dcd6f 100644
--- a/core/src/main/java/fj/Effect.java
+++ b/core/src/main/java/fj/Effect.java
@@ -14,8 +14,6 @@
 
 /**
  * Represents a side-effect.
- *
- * @version %build.number%
  */
 public final class Effect {
 
diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
index 9179cc43..cba4a589 100644
--- a/core/src/main/java/fj/Equal.java
+++ b/core/src/main/java/fj/Equal.java
@@ -22,8 +22,6 @@
 
 /**
  * Tests for equality between two objects.
- *
- * @version %build.number%
  */
 public final class Equal<A> {
 
diff --git a/core/src/main/java/fj/F.java b/core/src/main/java/fj/F.java
index 45cec4fe..1736f97b 100644
--- a/core/src/main/java/fj/F.java
+++ b/core/src/main/java/fj/F.java
@@ -16,10 +16,7 @@
 import static fj.data.Zipper.fromStream;
 
 /**
- * A transformation or function from <code>A</code> to <code>B</code>. This type can be represented
- * using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * A transformation or function from <code>A</code> to <code>B</code>.
  */
 @FunctionalInterface
 public interface F<A, B> extends Function<A, B> {
diff --git a/core/src/main/java/fj/F0.java b/core/src/main/java/fj/F0.java
index 9354568c..88d60a9e 100644
--- a/core/src/main/java/fj/F0.java
+++ b/core/src/main/java/fj/F0.java
@@ -6,9 +6,6 @@
 
 import java.util.function.Supplier;
 
-/**
- * Created by MarkPerry on 21/01/2015.
- */
 @FunctionalInterface
 public interface F0<A> extends Supplier<A> {
 
diff --git a/core/src/main/java/fj/F2.java b/core/src/main/java/fj/F2.java
index 4f7c306d..8b1aac20 100644
--- a/core/src/main/java/fj/F2.java
+++ b/core/src/main/java/fj/F2.java
@@ -14,9 +14,6 @@
 
 /**
  * A transformation function of arity-2 from <code>A</code> and <code>B</code> to <code>C</code>.
- * This type can be represented using the Java 7 closure syntax.
- *
- * @version %build.number%
  */
 @FunctionalInterface
 public interface F2<A, B, C> extends BiFunction<A, B, C> {
diff --git a/core/src/main/java/fj/F3.java b/core/src/main/java/fj/F3.java
index b8c4dcf3..b7efeb3a 100644
--- a/core/src/main/java/fj/F3.java
+++ b/core/src/main/java/fj/F3.java
@@ -2,9 +2,7 @@
 
 /**
  * A transformation function of arity-3 from <code>A</code>, <code>B</code> and <code>C</code> to
- * <code>D</code>. This type can be represented using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * <code>D</code>.
  */
 @FunctionalInterface
 public interface F3<A, B, C, D> {
diff --git a/core/src/main/java/fj/F4.java b/core/src/main/java/fj/F4.java
index d63f03a7..c3c5f882 100644
--- a/core/src/main/java/fj/F4.java
+++ b/core/src/main/java/fj/F4.java
@@ -2,9 +2,7 @@
 
 /**
  * A transformation function of arity-4 from <code>A</code>, <code>B</code>, <code>C</code> and
- * <code>D</code> to <code>E</code>. This type can be represented using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * <code>D</code> to <code>E</code>.
  */
 @FunctionalInterface
 public interface F4<A, B, C, D, E> {
diff --git a/core/src/main/java/fj/F5.java b/core/src/main/java/fj/F5.java
index f63ae797..574afb15 100644
--- a/core/src/main/java/fj/F5.java
+++ b/core/src/main/java/fj/F5.java
@@ -2,10 +2,7 @@
 
 /**
  * A transformation function of arity-5 from <code>A</code>, <code>B</code>, <code>C</code>,
- * <code>D</code> and <code>E</code> to <code>F$</code>. This type can be represented using the Java
- * 7 closure syntax.
- *
- * @version %build.number%
+ * <code>D</code> and <code>E</code> to <code>F$</code>.
  */
 @FunctionalInterface
 public interface F5<A, B, C, D, E, F$> {
diff --git a/core/src/main/java/fj/F6.java b/core/src/main/java/fj/F6.java
index 558c17fc..135e28fe 100644
--- a/core/src/main/java/fj/F6.java
+++ b/core/src/main/java/fj/F6.java
@@ -2,10 +2,7 @@
 
 /**
  * A transformation function of arity-6 from <code>A</code>, <code>B</code>, <code>C</code>,
- * <code>D</code>, <code>E</code> and <code>F$</code> to <code>G</code>. This type can be
- * represented using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * <code>D</code>, <code>E</code> and <code>F$</code> to <code>G</code>.
  */
 @FunctionalInterface
 public interface F6<A, B, C, D, E, F$, G> {
diff --git a/core/src/main/java/fj/F7.java b/core/src/main/java/fj/F7.java
index 05caefb4..a2542700 100644
--- a/core/src/main/java/fj/F7.java
+++ b/core/src/main/java/fj/F7.java
@@ -2,10 +2,7 @@
 
 /**
  * A transformation function of arity-7 from <code>A</code>, <code>B</code>, <code>C</code>,
- * <code>D</code>, <code>E</code>, <code>F$</code> and <code>G</code> to <code>H</code>. This type
- * can be represented using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * <code>D</code>, <code>E</code>, <code>F$</code> and <code>G</code> to <code>H</code>.
  */
 @FunctionalInterface
 public interface F7<A, B, C, D, E, F$, G, H> {
diff --git a/core/src/main/java/fj/F8.java b/core/src/main/java/fj/F8.java
index 5aa103f2..647fc14c 100644
--- a/core/src/main/java/fj/F8.java
+++ b/core/src/main/java/fj/F8.java
@@ -3,9 +3,7 @@
 /**
  * A transformation function of arity-8 from <code>A</code>, <code>B</code>, <code>C</code>,
  * <code>D</code>, <code>E</code>, <code>F$</code>, <code>G</code> and <code>H</code> to
- * <code>I</code>. This type can be represented using the Java 7 closure syntax.
- *
- * @version %build.number%
+ * <code>I</code>.
  */
 @FunctionalInterface
 public interface F8<A, B, C, D, E, F$, G, H, I> {
diff --git a/core/src/main/java/fj/Function.java b/core/src/main/java/fj/Function.java
index 995c179d..52819377 100644
--- a/core/src/main/java/fj/Function.java
+++ b/core/src/main/java/fj/Function.java
@@ -4,8 +4,6 @@
 
 /**
  * Transformations on functions.
- *
- * @version %build.number%
  */
 public final class Function {
   private Function() {
diff --git a/core/src/main/java/fj/Hash.java b/core/src/main/java/fj/Hash.java
index 703d96ee..241bcefb 100644
--- a/core/src/main/java/fj/Hash.java
+++ b/core/src/main/java/fj/Hash.java
@@ -17,8 +17,6 @@
 
 /**
  * Produces a hash code for an object which should attempt uniqueness.
- *
- * @version %build.number%
  */
 public final class Hash<A> {
   private final F<A, Integer> f;
diff --git a/core/src/main/java/fj/LcgRng.java b/core/src/main/java/fj/LcgRng.java
index 215b3572..cd918f5b 100644
--- a/core/src/main/java/fj/LcgRng.java
+++ b/core/src/main/java/fj/LcgRng.java
@@ -1,8 +1,6 @@
 package fj;
 
 /**
- * Created by MarkPerry on 7/07/2014.
- *
  * https://en.wikipedia.org/wiki/Linear_congruential_generator
  */
 public class LcgRng extends Rng {
diff --git a/core/src/main/java/fj/Monoid.java b/core/src/main/java/fj/Monoid.java
index bc09250d..bc05f33e 100644
--- a/core/src/main/java/fj/Monoid.java
+++ b/core/src/main/java/fj/Monoid.java
@@ -22,8 +22,6 @@
  * <li><em>Right Identity</em>; forall x. sum(x, zero()) == x</li>
  * <li><em>Associativity</em>; forall x y z. sum(sum(x, y), z) == sum(x, sum(y, z))</li>
  * </ul>
- *
- * @version %build.number%
  */
 public final class Monoid<A> {
 
diff --git a/core/src/main/java/fj/Ord.java b/core/src/main/java/fj/Ord.java
index ae4d3fda..2bf90450 100644
--- a/core/src/main/java/fj/Ord.java
+++ b/core/src/main/java/fj/Ord.java
@@ -10,8 +10,6 @@
 
 /**
  * Tests for ordering between two objects.
- *
- * @version %build.number%
  */
 public final class Ord<A> {
 
diff --git a/core/src/main/java/fj/Ordering.java b/core/src/main/java/fj/Ordering.java
index b22bcfcb..1828f69a 100644
--- a/core/src/main/java/fj/Ordering.java
+++ b/core/src/main/java/fj/Ordering.java
@@ -3,8 +3,6 @@
 /**
  * The comparison of two instances of a type may have one of three orderings; less than, equal or
  * greater than.
- *
- * @version %build.number%
  */
 public enum Ordering {
   /**
diff --git a/core/src/main/java/fj/P.java b/core/src/main/java/fj/P.java
index 587cdc9d..3e6efb74 100644
--- a/core/src/main/java/fj/P.java
+++ b/core/src/main/java/fj/P.java
@@ -4,8 +4,6 @@
 
 /**
  * Functions across products.
- *
- * @version %build.number%
  */
 public final class P {
   private P() {
diff --git a/core/src/main/java/fj/P1.java b/core/src/main/java/fj/P1.java
index 810e484d..5e575a4d 100644
--- a/core/src/main/java/fj/P1.java
+++ b/core/src/main/java/fj/P1.java
@@ -1,20 +1,12 @@
 package fj;
 
-import fj.data.Array;
-import fj.data.Either;
-import fj.data.List;
-import fj.data.Option;
-import fj.data.Stream;
-import fj.data.Validation;
+import fj.data.*;
 
 import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;
 
 import static fj.P.p;
-import static fj.Unit.unit;
-//import fj.data.*;
-
 
 public abstract class P1<A> implements F0<A> {
 
diff --git a/core/src/main/java/fj/P2.java b/core/src/main/java/fj/P2.java
index 841b356e..b4979f03 100644
--- a/core/src/main/java/fj/P2.java
+++ b/core/src/main/java/fj/P2.java
@@ -9,8 +9,6 @@
 
 /**
  * A product-2.
- *
- * @version %build.number%
  */
 public abstract class P2<A, B> {
   /**
diff --git a/core/src/main/java/fj/P3.java b/core/src/main/java/fj/P3.java
index 6e08a0ba..fff39ed8 100644
--- a/core/src/main/java/fj/P3.java
+++ b/core/src/main/java/fj/P3.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-3.
- *
- * @version %build.number%
  */
 public abstract class P3<A, B, C> {
   /**
diff --git a/core/src/main/java/fj/P4.java b/core/src/main/java/fj/P4.java
index 4fa2ef8c..d2dca64b 100644
--- a/core/src/main/java/fj/P4.java
+++ b/core/src/main/java/fj/P4.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-4.
- *
- * @version %build.number%
  */
 public abstract class P4<A, B, C, D> {
   /**
diff --git a/core/src/main/java/fj/P5.java b/core/src/main/java/fj/P5.java
index fabc4227..07138cb3 100644
--- a/core/src/main/java/fj/P5.java
+++ b/core/src/main/java/fj/P5.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-5.
- *
- * @version %build.number%
  */
 public abstract class P5<A, B, C, D, E> {
   /**
diff --git a/core/src/main/java/fj/P6.java b/core/src/main/java/fj/P6.java
index 670622c7..295b5427 100644
--- a/core/src/main/java/fj/P6.java
+++ b/core/src/main/java/fj/P6.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-6.
- *
- * @version %build.number%
  */
 @SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P6<A, B, C, D, E, F> {
diff --git a/core/src/main/java/fj/P7.java b/core/src/main/java/fj/P7.java
index 6c9ac804..17161f5d 100644
--- a/core/src/main/java/fj/P7.java
+++ b/core/src/main/java/fj/P7.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-7.
- *
- * @version %build.number%
  */
 @SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P7<A, B, C, D, E, F, G> {
diff --git a/core/src/main/java/fj/P8.java b/core/src/main/java/fj/P8.java
index f3902c5e..571d6a15 100644
--- a/core/src/main/java/fj/P8.java
+++ b/core/src/main/java/fj/P8.java
@@ -4,8 +4,6 @@
 
 /**
  * A product-8.
- *
- * @version %build.number%
  */
 @SuppressWarnings("UnnecessaryFullyQualifiedName")
 public abstract class P8<A, B, C, D, E, F, G, H> {
diff --git a/core/src/main/java/fj/Primitive.java b/core/src/main/java/fj/Primitive.java
index 2007c03c..6ded797e 100644
--- a/core/src/main/java/fj/Primitive.java
+++ b/core/src/main/java/fj/Primitive.java
@@ -2,8 +2,6 @@
 
 /**
  * Functions that convert between Java primitive types.
- *
- * @version %build.number%
  */
 public final class Primitive {
   private Primitive() {
diff --git a/core/src/main/java/fj/Rng.java b/core/src/main/java/fj/Rng.java
index 20b3358f..46c31b27 100644
--- a/core/src/main/java/fj/Rng.java
+++ b/core/src/main/java/fj/Rng.java
@@ -1,8 +1,5 @@
 package fj;
 
-/**
- * Created by MarkPerry on 7/07/2014.
- */
 public abstract class Rng {
 
 	public abstract P2<Rng, Integer> nextInt();
diff --git a/core/src/main/java/fj/Semigroup.java b/core/src/main/java/fj/Semigroup.java
index 1d767385..cd31e1e3 100644
--- a/core/src/main/java/fj/Semigroup.java
+++ b/core/src/main/java/fj/Semigroup.java
@@ -23,8 +23,6 @@
  * <ul>
  * <li><em>Associativity</em>; forall x. forall y. forall z. sum(sum(x, y), z) == sum(x, sum(y, z))</li>
  * </ul>
- *
- * @version %build.number%
  */
 public final class Semigroup<A> {
 
diff --git a/core/src/main/java/fj/Show.java b/core/src/main/java/fj/Show.java
index bfb2e151..8a21a281 100644
--- a/core/src/main/java/fj/Show.java
+++ b/core/src/main/java/fj/Show.java
@@ -27,8 +27,6 @@
 
 /**
  * Renders an object for display.
- *
- * @version %build.number%
  */
 public final class Show<A> {
   private final F<A, Stream<Character>> f;
diff --git a/core/src/main/java/fj/Try.java b/core/src/main/java/fj/Try.java
index d8a30130..8418a621 100644
--- a/core/src/main/java/fj/Try.java
+++ b/core/src/main/java/fj/Try.java
@@ -10,9 +10,6 @@
 import static fj.data.Validation.fail;
 import static fj.data.Validation.success;
 
-/**
- * Created by mperry on 24/07/2014.
- */
 public final class Try {
 
     private Try() {
diff --git a/core/src/main/java/fj/TryEffect.java b/core/src/main/java/fj/TryEffect.java
index cd1f75ab..a240e638 100644
--- a/core/src/main/java/fj/TryEffect.java
+++ b/core/src/main/java/fj/TryEffect.java
@@ -3,9 +3,6 @@
 import fj.data.Validation;
 import fj.function.*;
 
-/**
- * Created by mperry on 29/08/2014.
- */
 public final class TryEffect {
 
     private TryEffect(){}
diff --git a/core/src/main/java/fj/Unit.java b/core/src/main/java/fj/Unit.java
index c7471f21..76463ec1 100644
--- a/core/src/main/java/fj/Unit.java
+++ b/core/src/main/java/fj/Unit.java
@@ -2,8 +2,6 @@
 
 /**
  * The unit type which has only one value.
- *
- * @version %build.number%
  */
 public final class Unit {
   private static final Unit u = new Unit();
diff --git a/core/src/main/java/fj/control/Trampoline.java b/core/src/main/java/fj/control/Trampoline.java
index e3b58e1c..5c787f04 100644
--- a/core/src/main/java/fj/control/Trampoline.java
+++ b/core/src/main/java/fj/control/Trampoline.java
@@ -9,7 +9,7 @@
 
 /**
  * A Trampoline is a potentially branching computation that can be stepped through and executed in constant stack.
- * It represent suspendable coroutines with subroutine calls, reified as a data structure.
+ * It represents suspendable coroutines with subroutine calls, reified as a data structure.
  */
 public abstract class Trampoline<A> {
 
diff --git a/core/src/main/java/fj/data/IO.java b/core/src/main/java/fj/data/IO.java
index e2a94a38..69434728 100644
--- a/core/src/main/java/fj/data/IO.java
+++ b/core/src/main/java/fj/data/IO.java
@@ -1,9 +1,5 @@
 package fj.data;
 
-/**
- * Created by MarkPerry on 19/06/2014.
- */
-
 import fj.F;
 import fj.Unit;
 import fj.function.Try0;
diff --git a/core/src/main/java/fj/data/Iteratee.java b/core/src/main/java/fj/data/Iteratee.java
index be68ed02..e6177068 100644
--- a/core/src/main/java/fj/data/Iteratee.java
+++ b/core/src/main/java/fj/data/Iteratee.java
@@ -7,9 +7,6 @@
 import fj.P2;
 import fj.Unit;
 
-/**
- * 
- */
 public final class Iteratee {
 
   /** The input to an iteratee. */
diff --git a/core/src/main/java/fj/data/Java.java b/core/src/main/java/fj/data/Java.java
index 8691c09d..b3cb7e7f 100644
--- a/core/src/main/java/fj/data/Java.java
+++ b/core/src/main/java/fj/data/Java.java
@@ -35,8 +35,6 @@
 
 /**
  * Functions that convert between types from the core Java API.
- *
- * @version %build.number%
  */
 public final class Java {
   private Java() {
diff --git a/core/src/main/java/fj/data/Java8.java b/core/src/main/java/fj/data/Java8.java
index 46c5ca2a..184c01c5 100644
--- a/core/src/main/java/fj/data/Java8.java
+++ b/core/src/main/java/fj/data/Java8.java
@@ -19,9 +19,6 @@
 import java.util.function.Supplier;
 import java.util.stream.StreamSupport;
 
-/**
- * Created by mperry on 3/06/2014.
- */
 public final class Java8 {
 
     private Java8() {
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
index 9259900f..721ee9f1 100644
--- a/core/src/main/java/fj/data/List.java
+++ b/core/src/main/java/fj/data/List.java
@@ -28,8 +28,6 @@
 
 /**
  * Provides an in-memory, immutable, singly linked list.
- *
- * @version %build.number%
  */
 public abstract class List<A> implements Iterable<A> {
   private List() {
diff --git a/core/src/main/java/fj/data/NonEmptyList.java b/core/src/main/java/fj/data/NonEmptyList.java
index 34c8b957..96bf444a 100644
--- a/core/src/main/java/fj/data/NonEmptyList.java
+++ b/core/src/main/java/fj/data/NonEmptyList.java
@@ -14,8 +14,6 @@
 
 /**
  * Provides an in-memory, immutable, singly linked list with total <code>head</code> and <code>tail</code>.
- *
- * @version %build.number%
  */
 public final class NonEmptyList<A> implements Iterable<A> {
   /**
diff --git a/core/src/main/java/fj/data/Option.java b/core/src/main/java/fj/data/Option.java
index b6876c63..9831c48c 100644
--- a/core/src/main/java/fj/data/Option.java
+++ b/core/src/main/java/fj/data/Option.java
@@ -23,8 +23,6 @@
 /**
  * An optional value that may be none (no value) or some (a value). This type is a replacement for
  * the use of <code>null</code> with better type checks.
- *
- * @version %build.number%
  */
 public abstract class Option<A> implements Iterable<A> {
   private Option() {
diff --git a/core/src/main/java/fj/data/PriorityQueue.java b/core/src/main/java/fj/data/PriorityQueue.java
index 21f6ed6f..f685c36d 100644
--- a/core/src/main/java/fj/data/PriorityQueue.java
+++ b/core/src/main/java/fj/data/PriorityQueue.java
@@ -20,8 +20,6 @@
  * annotated with type K, are combined using a monoid of K and both the
  * key and value are stored in the leaf.  Priorities of the same value
  * are returned FIFO (first in, first out).
- *
- * Created by MarkPerry on 31 May 16.
  */
 public final class PriorityQueue<K, A> {
 
diff --git a/core/src/main/java/fj/data/Reader.java b/core/src/main/java/fj/data/Reader.java
index 9374e300..49010e31 100644
--- a/core/src/main/java/fj/data/Reader.java
+++ b/core/src/main/java/fj/data/Reader.java
@@ -4,7 +4,6 @@
 
 /**
  * The Reader monad (also called the function monad, so equivalent to the idea of F).
- * Created by MarkPerry on 7/07/2014.
  */
 public class Reader<A, B> {
 
diff --git a/core/src/main/java/fj/data/SafeIO.java b/core/src/main/java/fj/data/SafeIO.java
index eeef79f9..bcc16bf6 100644
--- a/core/src/main/java/fj/data/SafeIO.java
+++ b/core/src/main/java/fj/data/SafeIO.java
@@ -1,14 +1,5 @@
 package fj.data;
 
-import fj.F0;
-import fj.P;
-import fj.P1;
-
-import java.io.IOException;
-
-/**
- * Created by MarkPerry on 3/07/2014.
- */
 @FunctionalInterface
 public interface SafeIO<A> extends IO<A> {
 
diff --git a/core/src/main/java/fj/data/State.java b/core/src/main/java/fj/data/State.java
index f0156b36..c5b638a3 100644
--- a/core/src/main/java/fj/data/State.java
+++ b/core/src/main/java/fj/data/State.java
@@ -9,9 +9,6 @@
 import static fj.control.Trampoline.suspend;
 import static fj.data.List.cons;
 
-/**
- * Created by MarkPerry on 7/07/2014.
- */
 public final class State<S, A> {
 
   public static <S, A> State<S, A> unit(F<S, P2<S, A>> runF) {
diff --git a/core/src/main/java/fj/data/Stream.java b/core/src/main/java/fj/data/Stream.java
index bcf87dcf..8afa36ee 100644
--- a/core/src/main/java/fj/data/Stream.java
+++ b/core/src/main/java/fj/data/Stream.java
@@ -40,8 +40,6 @@
 
 /**
  * A lazy (not yet evaluated), immutable, singly linked list.
- *
- * @version %build.number%
  */
 public abstract class Stream<A> implements Iterable<A> {
   private Stream() {
diff --git a/core/src/main/java/fj/data/Tree.java b/core/src/main/java/fj/data/Tree.java
index f430d6d2..3b12d506 100644
--- a/core/src/main/java/fj/data/Tree.java
+++ b/core/src/main/java/fj/data/Tree.java
@@ -10,8 +10,6 @@
 
 /**
  * Provides a lazy, immutable, non-empty, multi-way tree (a rose tree).
- *
- * @version %build.number%
  */
 public final class Tree<A> implements Iterable<A> {
   /**
diff --git a/core/src/main/java/fj/data/Validation.java b/core/src/main/java/fj/data/Validation.java
index 60d8d2b2..5c1985a4 100644
--- a/core/src/main/java/fj/data/Validation.java
+++ b/core/src/main/java/fj/data/Validation.java
@@ -17,8 +17,6 @@
  * Isomorphic to {@link Either} but has renamed functions and represents failure on the left and success on the right.
  * This type also has accumulating functions that accept a {@link Semigroup} for binding computation while keeping error
  * values
- *
- * @version %build.number%
  */
 public class Validation<E, T> implements Iterable<T> {
   private final Either<E, T> e;
diff --git a/core/src/main/java/fj/data/Writer.java b/core/src/main/java/fj/data/Writer.java
index b6b4579b..ba2cded5 100644
--- a/core/src/main/java/fj/data/Writer.java
+++ b/core/src/main/java/fj/data/Writer.java
@@ -2,9 +2,6 @@
 
 import fj.*;
 
-/**
- * Created by MarkPerry on 7/07/2014.
- */
 public final class Writer<W, A> {
 
 	private final A val;
diff --git a/core/src/main/java/fj/data/hamt/BitSet.java b/core/src/main/java/fj/data/hamt/BitSet.java
index d164642d..9efbab34 100644
--- a/core/src/main/java/fj/data/hamt/BitSet.java
+++ b/core/src/main/java/fj/data/hamt/BitSet.java
@@ -13,8 +13,6 @@
  * For example, the BitSet("1011") represents the decimal number 11 and has
  * indices [3, 0] inclusive where the bit with the lowest value has the lowest
  * index and is the rightmost bit.
- *
- * Created by maperr on 31/05/2016.
  */
 public final class BitSet {
 
diff --git a/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java b/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
index f13ae90f..371f5435 100644
--- a/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
+++ b/core/src/main/java/fj/data/hamt/HashArrayMappedTrie.java
@@ -22,8 +22,6 @@
  * mapped trie.  It is a refined version of the more general notion of
  * a hash tree.
  *
- * @author Mark Perry
- *
  * Based on "Ideal Hash Trees" by Phil Bagwell, available from
  * http://lampwww.epfl.ch/papers/idealhashtrees.pdf
  */
diff --git a/core/src/main/java/fj/data/hamt/Node.java b/core/src/main/java/fj/data/hamt/Node.java
index f8a1ff40..af453925 100644
--- a/core/src/main/java/fj/data/hamt/Node.java
+++ b/core/src/main/java/fj/data/hamt/Node.java
@@ -10,8 +10,6 @@
 /**
  * A Hash Array Mapped Trie node that is either a key-value pair or a
  * Hash Array Mapped Trie.
- *
- * Created by maperr on 31/05/2016.
  */
 public final class Node<K, V> {
 
diff --git a/core/src/main/java/fj/data/package-info.java b/core/src/main/java/fj/data/package-info.java
index 911ef492..ae9577a7 100644
--- a/core/src/main/java/fj/data/package-info.java
+++ b/core/src/main/java/fj/data/package-info.java
@@ -1,6 +1,4 @@
 /**
  * Common algebraic data types.
- *
- * @version %build.number%
  */
 package fj.data;
diff --git a/core/src/main/java/fj/function/BigIntegers.java b/core/src/main/java/fj/function/BigIntegers.java
index 30d07a10..ac6584fc 100644
--- a/core/src/main/java/fj/function/BigIntegers.java
+++ b/core/src/main/java/fj/function/BigIntegers.java
@@ -10,8 +10,6 @@
 
 /**
  * Curried functions over Integers.
- *
- * @version %build.number%
  */
 public final class BigIntegers {
   private BigIntegers() {
diff --git a/core/src/main/java/fj/function/Booleans.java b/core/src/main/java/fj/function/Booleans.java
index 6211e870..bef1b347 100644
--- a/core/src/main/java/fj/function/Booleans.java
+++ b/core/src/main/java/fj/function/Booleans.java
@@ -15,8 +15,6 @@
 
 /**
  * Curried logical functions.
- *
- * @version %build.number%
  */
 public final class Booleans {
   private Booleans() {
diff --git a/core/src/main/java/fj/function/Doubles.java b/core/src/main/java/fj/function/Doubles.java
index 6fe1b033..aefcbfdc 100644
--- a/core/src/main/java/fj/function/Doubles.java
+++ b/core/src/main/java/fj/function/Doubles.java
@@ -11,8 +11,6 @@
 
 /**
  * Curried functions over Doubles.
- *
- * @version %build.number%
  */
 public final class Doubles {
   private Doubles() {
diff --git a/core/src/main/java/fj/function/Effect0.java b/core/src/main/java/fj/function/Effect0.java
index 5e499d2d..7644d394 100644
--- a/core/src/main/java/fj/function/Effect0.java
+++ b/core/src/main/java/fj/function/Effect0.java
@@ -4,9 +4,6 @@
 
 import static fj.Unit.unit;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect0 {
 
 	void f();
diff --git a/core/src/main/java/fj/function/Effect1.java b/core/src/main/java/fj/function/Effect1.java
index aff85774..1f3be909 100644
--- a/core/src/main/java/fj/function/Effect1.java
+++ b/core/src/main/java/fj/function/Effect1.java
@@ -9,9 +9,6 @@
 
 import static fj.Unit.unit;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect1<A> extends Consumer<A> {
 
 	void f(A a);
diff --git a/core/src/main/java/fj/function/Effect2.java b/core/src/main/java/fj/function/Effect2.java
index e4d7701a..b9a5ad5a 100644
--- a/core/src/main/java/fj/function/Effect2.java
+++ b/core/src/main/java/fj/function/Effect2.java
@@ -7,9 +7,6 @@
 
 import static fj.Unit.unit;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect2<A, B> extends BiConsumer<A, B> {
 
 	void f(A a, B b);
diff --git a/core/src/main/java/fj/function/Effect3.java b/core/src/main/java/fj/function/Effect3.java
index 0609584b..675d2301 100644
--- a/core/src/main/java/fj/function/Effect3.java
+++ b/core/src/main/java/fj/function/Effect3.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect3<A, B, C> {
 
 	void f(A a, B b, C c);
diff --git a/core/src/main/java/fj/function/Effect4.java b/core/src/main/java/fj/function/Effect4.java
index b24a7624..fdd20af8 100644
--- a/core/src/main/java/fj/function/Effect4.java
+++ b/core/src/main/java/fj/function/Effect4.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect4<A, B, C, D> {
 
 	void f(A a, B b, C c, D d);
diff --git a/core/src/main/java/fj/function/Effect5.java b/core/src/main/java/fj/function/Effect5.java
index 142be280..48634ac8 100644
--- a/core/src/main/java/fj/function/Effect5.java
+++ b/core/src/main/java/fj/function/Effect5.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect5<A, B, C, D, E> {
 
 	void f(A a, B b, C c, D d, E e);
diff --git a/core/src/main/java/fj/function/Effect6.java b/core/src/main/java/fj/function/Effect6.java
index fe72314b..f81cdf25 100644
--- a/core/src/main/java/fj/function/Effect6.java
+++ b/core/src/main/java/fj/function/Effect6.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect6<A, B, C, D, E, F> {
 
 	void f(A a, B b, C c, D d, E e, F f);
diff --git a/core/src/main/java/fj/function/Effect7.java b/core/src/main/java/fj/function/Effect7.java
index 944273af..4c77e4f4 100644
--- a/core/src/main/java/fj/function/Effect7.java
+++ b/core/src/main/java/fj/function/Effect7.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect7<A, B, C, D, E, F, G> {
 
 	void f(A a, B b, C c, D d, E e, F f, G g);
diff --git a/core/src/main/java/fj/function/Effect8.java b/core/src/main/java/fj/function/Effect8.java
index a8cfd3bb..d8b970ec 100644
--- a/core/src/main/java/fj/function/Effect8.java
+++ b/core/src/main/java/fj/function/Effect8.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface Effect8<A, B, C, D, E, F, G, H> {
 
 	void f(A a, B b, C c, D d, E e, F f, G g, H h);
diff --git a/core/src/main/java/fj/function/Integers.java b/core/src/main/java/fj/function/Integers.java
index 4b1b14b5..7f8fd0e8 100644
--- a/core/src/main/java/fj/function/Integers.java
+++ b/core/src/main/java/fj/function/Integers.java
@@ -16,8 +16,6 @@
 
 /**
  * Curried functions over Integers.
- *
- * @version %build.number%
  */
 public final class Integers {
   private Integers() {
diff --git a/core/src/main/java/fj/function/Longs.java b/core/src/main/java/fj/function/Longs.java
index 0989e8c0..2762f3e2 100644
--- a/core/src/main/java/fj/function/Longs.java
+++ b/core/src/main/java/fj/function/Longs.java
@@ -15,8 +15,6 @@
 
 /**
  * Curried functions over Longs.
- *
- * @version %build.number%
  */
 public final class Longs {
   private Longs() {
diff --git a/core/src/main/java/fj/function/Strings.java b/core/src/main/java/fj/function/Strings.java
index dadbfd22..1c239e85 100644
--- a/core/src/main/java/fj/function/Strings.java
+++ b/core/src/main/java/fj/function/Strings.java
@@ -12,8 +12,6 @@
 
 /**
  * Curried string functions.
- *
- * @version %build.number%
  */
 public final class Strings {
   private Strings() {
diff --git a/core/src/main/java/fj/function/Try0.java b/core/src/main/java/fj/function/Try0.java
index 9abfa6cd..7cdacfc1 100644
--- a/core/src/main/java/fj/function/Try0.java
+++ b/core/src/main/java/fj/function/Try0.java
@@ -15,7 +15,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to a <code>P1</code>.
  *
  * @see fj.Try#f(Try0)
- * @version %build.number%
  */
 
 public interface Try0<A, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try1.java b/core/src/main/java/fj/function/Try1.java
index b626890b..53f5d048 100644
--- a/core/src/main/java/fj/function/Try1.java
+++ b/core/src/main/java/fj/function/Try1.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F</code>.
  *
  * @see fj.Try#f(Try1)
- * @version %build.number%
  */
 
 public interface Try1<A, B, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try2.java b/core/src/main/java/fj/function/Try2.java
index 94438ccb..24e6a099 100644
--- a/core/src/main/java/fj/function/Try2.java
+++ b/core/src/main/java/fj/function/Try2.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F2</code>.
  *
  * @see fj.Try#f(Try2)
- * @version %build.number%
  */
 
 public interface Try2<A, B, C, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try3.java b/core/src/main/java/fj/function/Try3.java
index 7464c013..7c0de0eb 100644
--- a/core/src/main/java/fj/function/Try3.java
+++ b/core/src/main/java/fj/function/Try3.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F3</code>.
  *
  * @see fj.Try#f(Try3)
- * @version %build.number%
  */
 
 public interface Try3<A, B, C, D, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try4.java b/core/src/main/java/fj/function/Try4.java
index a7d969ed..d2b79d2c 100644
--- a/core/src/main/java/fj/function/Try4.java
+++ b/core/src/main/java/fj/function/Try4.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F4</code>.
  *
  * @see fj.Try#f(Try4)
- * @version %build.number%
  */
 
 public interface Try4<A, B, C, D, E, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try5.java b/core/src/main/java/fj/function/Try5.java
index b9855fd7..cbc1a93d 100644
--- a/core/src/main/java/fj/function/Try5.java
+++ b/core/src/main/java/fj/function/Try5.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F5</code>.
  *
  * @see fj.Try#f(Try5)
- * @version %build.number%
  */
 
 public interface Try5<A, B, C, D, E, F, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try6.java b/core/src/main/java/fj/function/Try6.java
index b66775c6..39bffbcb 100644
--- a/core/src/main/java/fj/function/Try6.java
+++ b/core/src/main/java/fj/function/Try6.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F6</code>.
  *
  * @see fj.Try#f(Try6)
- * @version %build.number%
  */
 
 public interface Try6<A, B, C, D, E, F, G, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try7.java b/core/src/main/java/fj/function/Try7.java
index 3bc09cd9..ab56ffcd 100644
--- a/core/src/main/java/fj/function/Try7.java
+++ b/core/src/main/java/fj/function/Try7.java
@@ -7,7 +7,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F7</code>.
  *
  * @see fj.Try#f(Try7)
- * @version %build.number%
  */
 
 public interface Try7<A, B, C, D, E, F, G, H, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/Try8.java b/core/src/main/java/fj/function/Try8.java
index 5b2f1b55..1486de3c 100644
--- a/core/src/main/java/fj/function/Try8.java
+++ b/core/src/main/java/fj/function/Try8.java
@@ -6,7 +6,6 @@
  * Used to instantiate a lambda that may throw an <code>Exception</code> before converting to an <code>F8</code>.
  *
  * @see fj.Try#f(Try8)
- * @version %build.number%
  */
 
 public interface Try8<A, B, C, D, E, F, G, H, I, Z extends Exception> {
diff --git a/core/src/main/java/fj/function/TryEffect0.java b/core/src/main/java/fj/function/TryEffect0.java
index 9a955c89..1ccaa9af 100644
--- a/core/src/main/java/fj/function/TryEffect0.java
+++ b/core/src/main/java/fj/function/TryEffect0.java
@@ -10,9 +10,6 @@
 import static fj.data.Option.none;
 import static fj.data.Option.some;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect0<Z extends Exception> {
 
 	void f() throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect1.java b/core/src/main/java/fj/function/TryEffect1.java
index 40db423d..1ddaca08 100644
--- a/core/src/main/java/fj/function/TryEffect1.java
+++ b/core/src/main/java/fj/function/TryEffect1.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect1<A, Z extends Exception> {
 
 	void f(A a) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect2.java b/core/src/main/java/fj/function/TryEffect2.java
index c9c13da9..c54f3fe7 100644
--- a/core/src/main/java/fj/function/TryEffect2.java
+++ b/core/src/main/java/fj/function/TryEffect2.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect2<A, B, Z extends Exception> {
 
 	void f(A a, B b) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect3.java b/core/src/main/java/fj/function/TryEffect3.java
index c581221e..4c3f19d0 100644
--- a/core/src/main/java/fj/function/TryEffect3.java
+++ b/core/src/main/java/fj/function/TryEffect3.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect3 <A, B, C, Z extends Exception> {
 
 	void f(A a, B b, C c) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect4.java b/core/src/main/java/fj/function/TryEffect4.java
index f99900ca..8b04ed5f 100644
--- a/core/src/main/java/fj/function/TryEffect4.java
+++ b/core/src/main/java/fj/function/TryEffect4.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect4<A, B, C, D, Z extends Exception> {
 
 	void f(A a, B b, C c, D d) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect5.java b/core/src/main/java/fj/function/TryEffect5.java
index d0445e3e..0bca874a 100644
--- a/core/src/main/java/fj/function/TryEffect5.java
+++ b/core/src/main/java/fj/function/TryEffect5.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect5<A, B, C, D, E, Z extends Exception> {
 
 	void f(A a, B b, C c, D d, E e) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect6.java b/core/src/main/java/fj/function/TryEffect6.java
index b4d81a41..d8f1f468 100644
--- a/core/src/main/java/fj/function/TryEffect6.java
+++ b/core/src/main/java/fj/function/TryEffect6.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect6<A, B, C, D, E, F, Z extends Exception> {
 
 	void f(A a, B b, C c, D d, E e, F f) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect7.java b/core/src/main/java/fj/function/TryEffect7.java
index 2e6004e9..133212dc 100644
--- a/core/src/main/java/fj/function/TryEffect7.java
+++ b/core/src/main/java/fj/function/TryEffect7.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect7<A, B, C, D, E, F, G, Z extends Exception> {
 
 	void f(A a, B b, C c, D d, E e, F f, G g) throws Z;
diff --git a/core/src/main/java/fj/function/TryEffect8.java b/core/src/main/java/fj/function/TryEffect8.java
index 4424bf00..d9c8c384 100644
--- a/core/src/main/java/fj/function/TryEffect8.java
+++ b/core/src/main/java/fj/function/TryEffect8.java
@@ -1,8 +1,5 @@
 package fj.function;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public interface TryEffect8<A, B, C, D, E, F, G, H, Z extends Exception> {
 
 	void f(A a, B b, C c, D d, E e, F f, G g, H h) throws Z;
diff --git a/core/src/main/java/fj/function/Visitor.java b/core/src/main/java/fj/function/Visitor.java
index bdca3b5e..ed0e7b53 100644
--- a/core/src/main/java/fj/function/Visitor.java
+++ b/core/src/main/java/fj/function/Visitor.java
@@ -15,8 +15,6 @@
 
 /**
  * The essence of the visitor design pattern expressed polymorphically.
- *
- * @version %build.number%
  */
 public final class Visitor {
   private Visitor() {
diff --git a/core/src/main/java/fj/function/package-info.java b/core/src/main/java/fj/function/package-info.java
index 6698bd5d..851bb534 100644
--- a/core/src/main/java/fj/function/package-info.java
+++ b/core/src/main/java/fj/function/package-info.java
@@ -1,6 +1,4 @@
 /**
  * A prelude of commonly used first-class functions
- *
- * @version %build.number%
  */
 package fj.function;
diff --git a/core/src/main/java/fj/package-info.java b/core/src/main/java/fj/package-info.java
index abeffe0f..c457d1e9 100644
--- a/core/src/main/java/fj/package-info.java
+++ b/core/src/main/java/fj/package-info.java
@@ -1,6 +1,4 @@
 /**
  * Types that set the premise for the existence of Functional Java.
- *
- * @version %build.number%
  */
 package fj;
diff --git a/core/src/main/java/fj/parser/Parser.java b/core/src/main/java/fj/parser/Parser.java
index 3ea6dd15..b5753f23 100644
--- a/core/src/main/java/fj/parser/Parser.java
+++ b/core/src/main/java/fj/parser/Parser.java
@@ -14,8 +14,6 @@
 /**
  * A parser is a function that takes some input (I) and produces either an error (E) or a parse result (A) and the
  * remainder of the input.
- *
- * @version %build.number%
  */
 public final class Parser<I, A, E> {
   private final F<I, Validation<E, Result<I, A>>> f;
diff --git a/core/src/main/java/fj/parser/Result.java b/core/src/main/java/fj/parser/Result.java
index b8acc6c4..843dd558 100644
--- a/core/src/main/java/fj/parser/Result.java
+++ b/core/src/main/java/fj/parser/Result.java
@@ -12,8 +12,6 @@
 
 /**
  * A parse result made up of a value (A) and the remainder of the parse input (I).
- *
- * @version %build.number%
  */
 public final class Result<I, A> implements Iterable<A> {
   private final I i;
diff --git a/core/src/main/java/fj/parser/package-info.java b/core/src/main/java/fj/parser/package-info.java
index 08140f0b..8f31c204 100644
--- a/core/src/main/java/fj/parser/package-info.java
+++ b/core/src/main/java/fj/parser/package-info.java
@@ -1,6 +1,4 @@
 /**
  * Parser combinators.
- *
- * @version %build.number%
  */
 package fj.parser;
diff --git a/core/src/test/java/fj/P2Test.java b/core/src/test/java/fj/P2Test.java
index dc25a3e0..d14b6199 100644
--- a/core/src/test/java/fj/P2Test.java
+++ b/core/src/test/java/fj/P2Test.java
@@ -3,9 +3,6 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-/**
- * Created by MarkPerry on 22/07/2014.
- */
 public class P2Test {
 
 	@Test
diff --git a/core/src/test/java/fj/ShowTest.java b/core/src/test/java/fj/ShowTest.java
index c516c0df..3d6d8354 100644
--- a/core/src/test/java/fj/ShowTest.java
+++ b/core/src/test/java/fj/ShowTest.java
@@ -6,9 +6,6 @@
 import static fj.data.Array.array;
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by MarkPerry on 4/06/2015.
- */
 public class ShowTest {
     @Test
     public void arrayShow() {
diff --git a/core/src/test/java/fj/data/ArrayTest.java b/core/src/test/java/fj/data/ArrayTest.java
index 883fc835..5713e5c3 100644
--- a/core/src/test/java/fj/data/ArrayTest.java
+++ b/core/src/test/java/fj/data/ArrayTest.java
@@ -7,9 +7,6 @@
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 14 Feb 16.
- */
 public class ArrayTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/BooleansTest.java b/core/src/test/java/fj/data/BooleansTest.java
index b0d3f969..84f7676f 100644
--- a/core/src/test/java/fj/data/BooleansTest.java
+++ b/core/src/test/java/fj/data/BooleansTest.java
@@ -10,9 +10,6 @@
 import static fj.function.Booleans.isnot;
 import static org.hamcrest.core.Is.is;
 
-/**
- * Created by amar on 28/01/15.
- */
 public class BooleansTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/JavaTest.java b/core/src/test/java/fj/data/JavaTest.java
index 2a9b6bfd..b8d99510 100644
--- a/core/src/test/java/fj/data/JavaTest.java
+++ b/core/src/test/java/fj/data/JavaTest.java
@@ -9,9 +9,6 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
-/**
- * Created by MarkPerry on 14/07/2014.
- */
 public class JavaTest {
 
 	@Test
diff --git a/core/src/test/java/fj/data/LazyStringTest.java b/core/src/test/java/fj/data/LazyStringTest.java
index 4f6325af..1adef2bd 100644
--- a/core/src/test/java/fj/data/LazyStringTest.java
+++ b/core/src/test/java/fj/data/LazyStringTest.java
@@ -6,9 +6,6 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 11/06/2015.
- */
 public class LazyStringTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/ListBufferTest.java b/core/src/test/java/fj/data/ListBufferTest.java
index 1dfbbc39..f2ed8286 100644
--- a/core/src/test/java/fj/data/ListBufferTest.java
+++ b/core/src/test/java/fj/data/ListBufferTest.java
@@ -5,9 +5,6 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 17/08/2015.
- */
 public class ListBufferTest {
 
 	@Test
diff --git a/core/src/test/java/fj/data/ListTest.java b/core/src/test/java/fj/data/ListTest.java
index ca7d0f22..9f09de0f 100644
--- a/core/src/test/java/fj/data/ListTest.java
+++ b/core/src/test/java/fj/data/ListTest.java
@@ -32,9 +32,6 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.*;
 
-/**
- * Created by MarkPerry on 16/01/2015.
- */
 public class ListTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/List_Traverse_Tests.java b/core/src/test/java/fj/data/List_Traverse_Tests.java
index 3d964f45..5b7c0d19 100644
--- a/core/src/test/java/fj/data/List_Traverse_Tests.java
+++ b/core/src/test/java/fj/data/List_Traverse_Tests.java
@@ -9,9 +9,6 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by amar on 28/12/14.
- */
 public class List_Traverse_Tests {
 
     @Test
diff --git a/core/src/test/java/fj/data/OptionTest.java b/core/src/test/java/fj/data/OptionTest.java
index 5a7bbdbf..e03d7aae 100644
--- a/core/src/test/java/fj/data/OptionTest.java
+++ b/core/src/test/java/fj/data/OptionTest.java
@@ -31,9 +31,6 @@
 import static fj.data.Validation.*;
 import static org.junit.Assert.*;
 
-/**
- * Created by MarkPerry on 15/01/2015.
- */
 public final class OptionTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/SeqTest.java b/core/src/test/java/fj/data/SeqTest.java
index 0b62db00..8a78ab31 100644
--- a/core/src/test/java/fj/data/SeqTest.java
+++ b/core/src/test/java/fj/data/SeqTest.java
@@ -33,9 +33,6 @@
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.*;
 
-/**
- * Created by MarkPerry on 16/01/2015.
- */
 public class SeqTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/SetTest.java b/core/src/test/java/fj/data/SetTest.java
index cdf2519c..ae65b687 100644
--- a/core/src/test/java/fj/data/SetTest.java
+++ b/core/src/test/java/fj/data/SetTest.java
@@ -8,9 +8,6 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 18/08/2015.
- */
 public class SetTest {
 
 	@Test
diff --git a/core/src/test/java/fj/data/StateTest.java b/core/src/test/java/fj/data/StateTest.java
index 37b21030..479efc38 100644
--- a/core/src/test/java/fj/data/StateTest.java
+++ b/core/src/test/java/fj/data/StateTest.java
@@ -5,9 +5,6 @@
 import static fj.P.p;
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by MarkPerry on 18/12/2014.
- */
 public class StateTest {
 
   @Test
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index 313678aa..f320f27a 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -38,9 +38,6 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by Zheka Kozlov on 27.05.2015.
- */
 public class StreamTest {
 
   @Test
diff --git a/core/src/test/java/fj/data/TreeMapTest.java b/core/src/test/java/fj/data/TreeMapTest.java
index 96cb95b2..77352989 100644
--- a/core/src/test/java/fj/data/TreeMapTest.java
+++ b/core/src/test/java/fj/data/TreeMapTest.java
@@ -19,9 +19,6 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by MarkPerry on 11/01/2015.
- */
 public class TreeMapTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/TreeTest.java b/core/src/test/java/fj/data/TreeTest.java
index 811826fb..fd43c852 100644
--- a/core/src/test/java/fj/data/TreeTest.java
+++ b/core/src/test/java/fj/data/TreeTest.java
@@ -1,15 +1,11 @@
 package fj.data;
 
-import org.junit.Assert;
 import org.junit.Test;
 
 import static fj.data.Tree.leaf;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 29/08/2015.
- */
 public class TreeTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/UnitTest.java b/core/src/test/java/fj/data/UnitTest.java
index eef15887..1fab0a7b 100644
--- a/core/src/test/java/fj/data/UnitTest.java
+++ b/core/src/test/java/fj/data/UnitTest.java
@@ -4,9 +4,6 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-/**
- * Created by MarkPerry on 17/01/2015.
- */
 public class UnitTest {
 
     @Test
diff --git a/core/src/test/java/fj/function/TestEffect.java b/core/src/test/java/fj/function/TestEffect.java
index 00da26f0..de2f5c5f 100644
--- a/core/src/test/java/fj/function/TestEffect.java
+++ b/core/src/test/java/fj/function/TestEffect.java
@@ -1,11 +1,7 @@
 package fj.function;
 
-import fj.F;
 import org.junit.Test;
 
-/**
- * Created by mperry on 28/08/2014.
- */
 public class TestEffect {
 
 	@Test
diff --git a/demo/src/main/java/fj/demo/IODemo.java b/demo/src/main/java/fj/demo/IODemo.java
index ea313e77..aad8e41b 100644
--- a/demo/src/main/java/fj/demo/IODemo.java
+++ b/demo/src/main/java/fj/demo/IODemo.java
@@ -10,9 +10,6 @@
 import static fj.data.LazyString.unlines_;
 import static java.lang.System.out;
 
-/**
- * Created by MarkPerry on 13/06/2015.
- */
 public class IODemo {
 
     public static void main(String[] args) {
diff --git a/demo/src/main/java/fj/demo/StateDemo_Greeter.java b/demo/src/main/java/fj/demo/StateDemo_Greeter.java
index 578f414e..707a1f9f 100644
--- a/demo/src/main/java/fj/demo/StateDemo_Greeter.java
+++ b/demo/src/main/java/fj/demo/StateDemo_Greeter.java
@@ -3,9 +3,6 @@
 import fj.P;
 import fj.data.State;
 
-/**
- * Created by mperry on 4/08/2014.
- */
 public class StateDemo_Greeter {
 
     public static void main(String args[]) {
diff --git a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
index ef1a09cd..75de4823 100644
--- a/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
+++ b/demo/src/main/java/fj/demo/StateDemo_VendingMachine.java
@@ -6,9 +6,6 @@
 import static fj.demo.StateDemo_VendingMachine.Input.COIN;
 import static fj.demo.StateDemo_VendingMachine.Input.TURN;
 
-/**
- * Created by MarkPerry on 20/07/2014.
- */
 public class StateDemo_VendingMachine {
 
 	public enum Input { COIN, TURN }
diff --git a/demo/src/main/java/fj/demo/WriterDemo_Halver.java b/demo/src/main/java/fj/demo/WriterDemo_Halver.java
index 8473e588..9e6c6dac 100644
--- a/demo/src/main/java/fj/demo/WriterDemo_Halver.java
+++ b/demo/src/main/java/fj/demo/WriterDemo_Halver.java
@@ -6,9 +6,6 @@
 
 import static fj.Monoid.stringMonoid;
 
-/**
- * Created by mperry on 4/08/2014.
- */
 public class WriterDemo_Halver {
 
     public static void main(String args[]) {
diff --git a/demo/src/main/java/fj/demo/optic/LensPerson.java b/demo/src/main/java/fj/demo/optic/LensPerson.java
index 51f5e103..641543e9 100644
--- a/demo/src/main/java/fj/demo/optic/LensPerson.java
+++ b/demo/src/main/java/fj/demo/optic/LensPerson.java
@@ -6,9 +6,6 @@
 
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by MarkPerry on 23/06/2015.
- */
 public class LensPerson {
 
     static final class Person {
diff --git a/demo/src/main/java/fj/demo/realworld/Chapter7.java b/demo/src/main/java/fj/demo/realworld/Chapter7.java
index c239a5bf..bc414e4f 100644
--- a/demo/src/main/java/fj/demo/realworld/Chapter7.java
+++ b/demo/src/main/java/fj/demo/realworld/Chapter7.java
@@ -8,8 +8,6 @@
 import static fj.data.IOFunctions.*;
 
 /**
- * Created by MarkPerry on 11/06/2015.
- *
  * Examples from Chapter 7 of Real World Haskell, http://book.realworldhaskell.org/.
  *
  * Currently just ch07/toupper-lazy4.hs.
diff --git a/demo/src/test/java/fj/EmptyTest.java b/demo/src/test/java/fj/EmptyTest.java
index e112a97a..13675822 100644
--- a/demo/src/test/java/fj/EmptyTest.java
+++ b/demo/src/test/java/fj/EmptyTest.java
@@ -5,9 +5,6 @@
 
 import org.junit.Assert;
 
-/**
- * Created by MarkPerry on 30/08/2015.
- */
 public class EmptyTest {
 
     @Ignore @Test
diff --git a/java-core/src/main/java/fj/java/util/ListUtil.java b/java-core/src/main/java/fj/java/util/ListUtil.java
index 17fb5519..ffab7968 100644
--- a/java-core/src/main/java/fj/java/util/ListUtil.java
+++ b/java-core/src/main/java/fj/java/util/ListUtil.java
@@ -5,9 +5,6 @@
 
 import java.util.List;
 
-/**
- * Created by MarkPerry on 28/08/2015.
- */
 public class ListUtil {
 
     public static <A, B> List<B> map(List<A> list, F<A, B> f) {
diff --git a/java-core/src/test/java/fj/EmptyTest.java b/java-core/src/test/java/fj/EmptyTest.java
index d1088c03..1c126bfa 100644
--- a/java-core/src/test/java/fj/EmptyTest.java
+++ b/java-core/src/test/java/fj/EmptyTest.java
@@ -4,9 +4,6 @@
 import org.junit.Test;
 import org.junit.Assert;
 
-/**
- * Created by MarkPerry on 30/08/2015.
- */
 public class EmptyTest {
 
     @Ignore @Test
diff --git a/performance/src/main/java/fj/data/dummy/DummyClass.java b/performance/src/main/java/fj/data/dummy/DummyClass.java
index 72cc5c34..a94dcdde 100644
--- a/performance/src/main/java/fj/data/dummy/DummyClass.java
+++ b/performance/src/main/java/fj/data/dummy/DummyClass.java
@@ -1,8 +1,5 @@
 package fj.data.dummy;
 
-/**
- * Created by MarkPerry on 5 Feb 16.
- */
 public class DummyClass {
 
 }
diff --git a/performance/src/test/java/fj/data/dummy/DummyTest.java b/performance/src/test/java/fj/data/dummy/DummyTest.java
index d3865433..49722bcd 100644
--- a/performance/src/test/java/fj/data/dummy/DummyTest.java
+++ b/performance/src/test/java/fj/data/dummy/DummyTest.java
@@ -3,9 +3,6 @@
 import org.junit.Ignore;
 import org.junit.Test;
 
-/**
- * Created by MarkPerry on 5 Feb 16.
- */
 public class DummyTest {
 
     @Test
diff --git a/props-core/src/test/java/fj/MemoisationTest.java b/props-core/src/test/java/fj/MemoisationTest.java
index 865f76a3..605546ef 100644
--- a/props-core/src/test/java/fj/MemoisationTest.java
+++ b/props-core/src/test/java/fj/MemoisationTest.java
@@ -12,9 +12,6 @@
 import static fj.test.Property.property;
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by mperry on 14/07/2014.
- */
 @RunWith(PropertyTestRunner.class)
 public class MemoisationTest {
 
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 044595d0..accc3394 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -13,9 +13,6 @@
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by MarkPerry on 4/12/2014.
- */
 public class ReaderTest {
 
     @Test
diff --git a/props-core/src/test/java/fj/data/TestRngState.java b/props-core/src/test/java/fj/data/TestRngState.java
index 5f5f81bb..41143c17 100644
--- a/props-core/src/test/java/fj/data/TestRngState.java
+++ b/props-core/src/test/java/fj/data/TestRngState.java
@@ -17,9 +17,6 @@
 import static fj.test.Property.property;
 import static fj.test.Variant.variant;
 
-/**
- * Created by mperry on 4/08/2014.
- */
 public class TestRngState {
 
 	static List<Integer> expected1 = List.list(4,4,2,2,2,5,3,3,1,5);
diff --git a/props-core/src/test/java/fj/data/WriterTest.java b/props-core/src/test/java/fj/data/WriterTest.java
index 25f99b22..50134da3 100644
--- a/props-core/src/test/java/fj/data/WriterTest.java
+++ b/props-core/src/test/java/fj/data/WriterTest.java
@@ -16,9 +16,6 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
-/**
- * Created by MarkPerry on 17/12/2014.
- */
 public class WriterTest {
 
     @Test
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
index b7ed83f5..446716c2 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeProperties.java
@@ -1,6 +1,5 @@
 package fj.data.fingertrees;
 
-import fj.P2;
 import fj.data.Stream;
 import fj.test.Property;
 import fj.test.reflect.CheckParams;
@@ -12,9 +11,6 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
-/**
- * Created by MarkPerry on 10/10/2015.
- */
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 10000)
 public class FingerTreeProperties {
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index b25fff51..a26fdc89 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -14,10 +14,6 @@
 import static org.junit.Assert.assertThat;
 import static org.hamcrest.core.Is.is;
 
-
-/**
- * Created by MarkPerry on 10/10/2015.
- */
 public class FingerTreeTest {
 
     public static final int SIZE = 10;
diff --git a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
index 6c3f91a9..fbda987b 100644
--- a/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
+++ b/props-core/src/test/java/fj/data/hamt/BitSetProperties.java
@@ -31,10 +31,6 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
-/**
- * Created by maperr on 31/05/2016.
- */
-
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 10000)
 public class BitSetProperties {
diff --git a/props-core/src/test/java/fj/data/properties/NonEmptyListProperties.java b/props-core/src/test/java/fj/data/properties/NonEmptyListProperties.java
index 256fb3a8..64ce1934 100644
--- a/props-core/src/test/java/fj/data/properties/NonEmptyListProperties.java
+++ b/props-core/src/test/java/fj/data/properties/NonEmptyListProperties.java
@@ -25,9 +25,6 @@
 import static fj.test.Property.property;
 import static java.lang.Math.min;
 
-/**
- * Created by Zheka Kozlov on 02.06.2015.
- */
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 10000)
 public class NonEmptyListProperties {
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index 2bde7e6e..c2e46eca 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -26,9 +26,6 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertThat;
 
-/**
- * Created by MarkPerry on 18 Jun 16.
- */
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 100)
 public class PriorityQueueProperties {
diff --git a/props-core/src/test/java/fj/data/properties/SetProperties.java b/props-core/src/test/java/fj/data/properties/SetProperties.java
index 5349b650..2657b937 100644
--- a/props-core/src/test/java/fj/data/properties/SetProperties.java
+++ b/props-core/src/test/java/fj/data/properties/SetProperties.java
@@ -15,9 +15,6 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
-/**
- * Created by MarkPerry on 18/08/2015.
- */
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 10000)
 public class SetProperties {
diff --git a/props-core/src/test/java/fj/data/properties/TreeMapProperties.java b/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
index eb71749b..50b323ff 100644
--- a/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
+++ b/props-core/src/test/java/fj/data/properties/TreeMapProperties.java
@@ -23,9 +23,6 @@
 import static fj.test.Arbitrary.arbTreeMap;
 import static fj.test.Property.*;
 
-/**
- * Created by MarkPerry on 29/08/2015.
- */
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 10000)
 public class TreeMapProperties {
diff --git a/props-core/src/test/java/fj/data/properties/ValidationProperties.java b/props-core/src/test/java/fj/data/properties/ValidationProperties.java
index f5205d73..a47383ab 100644
--- a/props-core/src/test/java/fj/data/properties/ValidationProperties.java
+++ b/props-core/src/test/java/fj/data/properties/ValidationProperties.java
@@ -13,9 +13,6 @@
 import static fj.test.Property.implies;
 import static fj.test.Property.prop;
 
-/**
- * Created by MarkPerry on 3/07/2015.
- */
 @RunWith(PropertyTestRunner.class)
 public class ValidationProperties {
 
diff --git a/quickcheck/src/main/java/fj/data/test/PropertyAssert.java b/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
index 00187b15..d37c69a3 100644
--- a/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
+++ b/quickcheck/src/main/java/fj/data/test/PropertyAssert.java
@@ -5,9 +5,6 @@
 import fj.test.Property;
 import org.junit.Assert;
 
-/**
- * Created by MarkPerry on 18/12/2014.
- */
 public final class PropertyAssert {
 
     private PropertyAssert(){}
diff --git a/quickcheck/src/test/java/fj/data/test/TestNull.java b/quickcheck/src/test/java/fj/data/test/TestNull.java
index fe9dc843..0d547149 100644
--- a/quickcheck/src/test/java/fj/data/test/TestNull.java
+++ b/quickcheck/src/test/java/fj/data/test/TestNull.java
@@ -8,9 +8,6 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 
-/**
- * Created by MarkPerry on 3/07/2014.
- */
 public class TestNull {
 
 	@Test
diff --git a/quickcheck/src/test/java/fj/test/TestRand.java b/quickcheck/src/test/java/fj/test/TestRand.java
index 1ca7c749..ea2cbce8 100644
--- a/quickcheck/src/test/java/fj/test/TestRand.java
+++ b/quickcheck/src/test/java/fj/test/TestRand.java
@@ -9,9 +9,6 @@
 
 import static org.junit.Assert.assertTrue;
 
-/**
- * Created by MarkPerry on 4/06/2015.
- */
 public class TestRand {
 
     @Test

From 8c8663a039959b07daf8c14c9a974dc5bf389960 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 18:50:17 +1000
Subject: [PATCH 315/336] Updated release process

---
 etc/release-process.txt | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/etc/release-process.txt b/etc/release-process.txt
index b22ec4e4..3bfb7bbd 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -45,12 +45,10 @@ Setup Artifact Signing
 ======================
 The below text is a summary from https://gist.github.com/phit/bd3c6d156a2fa5f3b1bc15fa94b3256c.
 
-As of 2021-02-12, for Windows download Gpg4win 3.1.15 at https://gpg4win.org/index.html.  You need to provide 3 things:
-- the public key id
-- the path to the secret key ring file for your private key
-- the passphrase for your private key
+As of 2022-02-11, for Windows download Gpg4win 3.1.16 from https://files.gpg4win.org/.
 
 Open a command prompt and run "gpg --gen-key" and follow the prompts.
+
 Get your key id by running: "gpg --list-key"
 
 Example output:
@@ -68,9 +66,9 @@ sub   rsa2048 2017-06-17 [E] [expires: 2019-06-17]
 
 In this case we only have one key, 77273D57FA5140E5A91905087A1B92B81840D019 or short* 1840D019 which is basically just the last 8 characters of the long ID.
 
-Export the key using "gpg --export-secret-key <key> > %UserProfile%\secring.gpg"
+Export the key using "gpg --export-secret-key <key> >%UserProfile%\secring.gpg"
 
-In %UserProfile%\.gradle\gradle.properties, set the values below:
+Create the file %UserProfile%\.gradle\gradle.properties, set the values below:
 
 signing.keyId=XXXXXXXX
 signing.password=mypassword
@@ -90,6 +88,7 @@ sub   rsa3072 2021-02-12 [E] [expires: 2023-02-12]
 C:\repos\functionaljava>gpg --keyserver hkp://keyserver.ubuntu.com --send-keys E86A4EC34F25A9CF6118582A7985AAE03F41B2F9
 gpg: sending key 7985AAE03F41B2F9 to hkp://keyserver.ubuntu.com
 
+
 gradle upload (takes about 3 mins)
 
 

From 3eea643f16a7f98127f7818c900f25a5752c1781 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 20:56:10 +1000
Subject: [PATCH 316/336] Update release doc and Github readme

---
 README.adoc             | 25 +++++++++++++------------
 build.gradle            |  1 -
 etc/release-process.txt | 10 ++++------
 gradle.properties       |  5 +++--
 4 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/README.adoc b/README.adoc
index cb53d003..d57b22b4 100644
--- a/README.adoc
+++ b/README.adoc
@@ -22,8 +22,9 @@ Important URLs for the project are:
 
 * Website, http://www.functionaljava.org
 * Website repository, http://github.com/functionaljava/functionaljava.github.io
-* Travis continuous integration build, https://travis-ci.org/functionaljava/functionaljava
-* Sonatype Repository, https://oss.sonatype.org/content/groups/public/org/functionaljava/
+* Travis continuous integration build, https://app.travis-ci.com/github/functionaljava/functionaljava
+* Sonatype repository, https://oss.sonatype.org/content/groups/public/org/functionaljava/
+* Maven Central repository, https://mvnrepository.com/artifact/org.functionaljava/functionaljava
 
 == Downloading
 
@@ -35,12 +36,12 @@ The Functional Java artifact is published to Maven Central using the group `org.
 * Java 8 specific support (`functionaljava-java8`)
 * property based testing (`functionaljava-quickcheck` or `functionaljava-quickcheck_1.8` if you use Java 8+)
 
-The latest stable version is `4.8.1`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `4.9`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.8.1"
-compile "org.functionaljava:functionaljava-java8:4.8.1"
-compile "org.functionaljava:functionaljava-quickcheck:4.8.1"
-compile "org.functionaljava:functionaljava-java-core:4.8.1"
+compile "org.functionaljava:functionaljava:4.9"
+compile "org.functionaljava:functionaljava-java8:4.9"
+compile "org.functionaljava:functionaljava-quickcheck:4.9"
+compile "org.functionaljava:functionaljava-java-core:4.9"
 ----
 
 and in Maven:
@@ -48,22 +49,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.8.1</version>
+    <version>4.9</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java8</artifactId>
-    <version>4.8.1</version>
+    <version>4.9</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.8.1</version>
+    <version>4.9</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-java-core</artifactId>
-    <version>4.8.1</version>
+    <version>4.9</version>
 </dependency>
 ----
 
@@ -71,7 +72,7 @@ and in Maven:
 
 FunctionalJava uses the Retro Lambda project to backport Java 8 lambdas to Java 6 bytecode.  This requires access to both JDK 6 and 8.  The build system requires the environment variables `JAVA6_HOME` and `JAVA8_HOME` to refer to the appropriate directories.
 
-Building is done using Gradle 2.13.  In the root directory run:
+Building is done using Gradle 6.8.3.  In the root directory run:
 ----
 ./gradlew
 ----
diff --git a/build.gradle b/build.gradle
index 1ceb4fb9..cc2e265c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -41,7 +41,6 @@ allprojects {
 	defaultTasks "build"
 
     ext {
-        isSnapshot = true
         fjBaseVersion = "5.0"
 
         snapshotAppendix = "-SNAPSHOT"
diff --git a/etc/release-process.txt b/etc/release-process.txt
index 3bfb7bbd..e4b35e2d 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -4,13 +4,11 @@ Current Release Process
 
 Go through the issues and pull requests and set the Label and Milestone field.  Add information to /etc/release-notes/release-notes-<version>.adoc.
 
-Update build.gradle:
-* set isSnapshot to false
-* set useRetroLambda to true
-
 Update gradle.properties:
+* set isSnapshot to false
 * Set signingEnabled to true
 
+
 Run the build command:
 gradlew clean build upload
 
@@ -24,8 +22,8 @@ Login to Sonatype and verify the release:
 Commit changes
 
 Increase the version:
-* Edit build.gradle: update isSnapshot to true, increase fjBaseVersion, update fjConsumeVersion, update useRetroLambda.
-* Edit gradle.properties: set signingEnabled to false
+* Edit build.gradle: increase fjBaseVersion, update fjConsumeVersion.
+* Edit gradle.properties: set signingEnabled to false, set isSnapshot to true
 
 Commit changes and push.  Notes that CI builds using Travis and Jenkins will fail with the release due to lack of configured signing.
 
diff --git a/gradle.properties b/gradle.properties
index 1f1f4ed9..1171b13a 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,7 +1,8 @@
 
+signingEnabled = false
+isSnapshot = true
+
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signingEnabled = false
-
 org.gradle.parallel = true

From ce361b4466565cd4b074c7a11937f804b470bcba Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 20:56:42 +1000
Subject: [PATCH 317/336] Re-added openjdk8 for FJ 5

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index a7465305..fa0798a4 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,7 +4,7 @@ sudo: false
 language: java
 
 jdk:
- - openjdk10
+ - openjdk8
  - openjdk11
  - openjdk-ea
 

From ba209425860e146c95386e9de314698c71e8e3cf Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 21:05:36 +1000
Subject: [PATCH 318/336] Updated Travis CI link at the top of the readme

---
 README.adoc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.adoc b/README.adoc
index d57b22b4..4ede16b7 100644
--- a/README.adoc
+++ b/README.adoc
@@ -1,6 +1,6 @@
 = Functional Java
 
-image:https://travis-ci.org/functionaljava/functionaljava.svg?branch=master["Build Status", link="https://travis-ci.org/functionaljava/functionaljava"]
+image:https://travis-ci.org/functionaljava/functionaljava.svg?branch=master["Build Status", link="https://app.travis-ci.com/github/functionaljava/functionaljava"]
 image:https://codecov.io/gh/functionaljava/functionaljava/branch/master/graph/badge.svg["Code Coverage", link="https://codecov.io/gh/functionaljava/functionaljava"]
 image:https://badges.gitter.im/functionaljava/functionaljava.svg[link="https://gitter.im/functionaljava/functionaljava?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"]
 
@@ -8,7 +8,7 @@ image::http://www.functionaljava.org/img/logo-600x144.png[]
 
 Functional Java is an open source library facilitating functional programming in Java. The library implements numerous basic and advanced programming abstractions that assist composition oriented development. Functional Java also serves as a platform for learning functional programming concepts by introducing these concepts using a familiar language.
 
-The library is intended for use in production applications and is thoroughly tested using the technique of automated specification-based testing with ScalaCheck and Functional Java's quickcheck module. Functional Java is compiled with Java 8 targeting Java 7 bytecode. The use of lambdas within the project are backported with the Retro Lambda library, supporting Java versions 6 to 8.
+The library is intended for use in production applications and is thoroughly tested using the technique of automated specification-based testing with ScalaCheck and Functional Java's quickcheck module. Functional Java is compiled with Java 8 targeting Java 7 bytecode. The use of lambdas within the project are back ported with the Retro Lambda library, supporting Java versions 6 to 8.
 
 Functional Java provides abstractions for the following types:
 

From 80862115da1e0d065b95e394bd517851b314d821 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 21:47:41 +1000
Subject: [PATCH 319/336] Prep for 5.0 release

---
 build.gradle      | 1 +
 gradle.properties | 3 +--
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index cc2e265c..1e7bf98c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -41,6 +41,7 @@ allprojects {
 	defaultTasks "build"
 
     ext {
+        isSnapshot = false
         fjBaseVersion = "5.0"
 
         snapshotAppendix = "-SNAPSHOT"
diff --git a/gradle.properties b/gradle.properties
index 1171b13a..d18e6a6f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,6 +1,5 @@
 
-signingEnabled = false
-isSnapshot = true
+signingEnabled = true
 
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd

From a4ff75ed351c2e0996399d2b059a76fa158317fc Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 11 Feb 2022 22:11:47 +1000
Subject: [PATCH 320/336] Prep for FJ 5.1

---
 build.gradle      | 4 ++--
 gradle.properties | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/build.gradle b/build.gradle
index 1e7bf98c..70485ec9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -41,8 +41,8 @@ allprojects {
 	defaultTasks "build"
 
     ext {
-        isSnapshot = false
-        fjBaseVersion = "5.0"
+        isSnapshot = true
+        fjBaseVersion = "5.1"
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
diff --git a/gradle.properties b/gradle.properties
index d18e6a6f..50202eda 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -1,5 +1,5 @@
 
-signingEnabled = true
+signingEnabled = false
 
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd

From 56a9a51594e1a4030ff27f4db345e7b736489c8d Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sun, 13 Feb 2022 23:14:27 +1000
Subject: [PATCH 321/336] Added signing parameters to the properties file

---
 gradle.properties | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gradle.properties b/gradle.properties
index 50202eda..dde4512b 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,4 +4,8 @@ signingEnabled = false
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
+signing.keyId=
+signing.password=
+signing.secretKeyRingFile=
+
 org.gradle.parallel = true

From 3c254bb3b6840512f896bb3348e3e5401837929e Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 14 Feb 2022 20:46:29 +1000
Subject: [PATCH 322/336] Fix series/5.x build.  Removed extra jdk's for series
 5.x.

---
 .travis.yml       | 11 -----------
 gradle.properties |  6 +++---
 2 files changed, 3 insertions(+), 14 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index fa0798a4..bc3fc57f 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,24 +5,13 @@ language: java
 
 jdk:
  - openjdk8
- - openjdk11
- - openjdk-ea
 
 matrix:
   fast_finish: true
 
   include:
-  - jdk: openjdk12
-    script:
-      - ./gradlew build coverage -s -i
-    after_success:
-      - bash <(curl -s https://codecov.io/bash)
-      - '[ "$TRAVIS_BRANCH" = "series/5.x" -a "$TRAVIS_PULL_REQUEST" = "false" -a -z "$TRAVIS_TAG" ]
-        && ./gradlew uploadArchives'
 
   allow_failures:
-  - jdk: openjdk10
-  - jdk: openjdk-ea
 
 script:
   - ./gradlew clean test
diff --git a/gradle.properties b/gradle.properties
index dde4512b..6ee9a768 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,8 +4,8 @@ signingEnabled = false
 sonatypeUsername = incorrectUser
 sonatypePassword = incorrectPwd
 
-signing.keyId=
-signing.password=
-signing.secretKeyRingFile=
+#signing.keyId=
+#signing.password=
+#signing.secretKeyRingFile=
 
 org.gradle.parallel = true

From 474a49ca5b7760cd79243ca4b428ea7ddef0b72e Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 14 Feb 2022 22:18:36 +1000
Subject: [PATCH 323/336] Upgrade Junit to 4.13.2, fixed deprecations.  Update
 gradle-versions-plugin, junit-vintage-engine

---
 build.gradle                                              | 8 ++++----
 core/src/test/java/fj/ClassTest.java                      | 2 +-
 core/src/test/java/fj/DigitTest.java                      | 2 +-
 core/src/test/java/fj/MonoidTest.java                     | 2 +-
 core/src/test/java/fj/TryTest.java                        | 2 +-
 core/src/test/java/fj/control/db/TestDbState.java         | 2 +-
 core/src/test/java/fj/data/ArrayTest.java                 | 2 +-
 core/src/test/java/fj/data/DListTest.java                 | 2 +-
 core/src/test/java/fj/data/LazyStringTest.java            | 2 +-
 core/src/test/java/fj/data/ListBufferTest.java            | 2 +-
 core/src/test/java/fj/data/SetTest.java                   | 2 +-
 core/src/test/java/fj/data/StreamTest.java                | 2 +-
 core/src/test/java/fj/data/TreeMapTest.java               | 2 +-
 core/src/test/java/fj/data/TreeTest.java                  | 2 +-
 core/src/test/java/fj/data/TreeZipperTest.java            | 2 +-
 core/src/test/java/fj/data/ValidationTest.java            | 2 +-
 core/src/test/java/fj/data/ZipperTest.java                | 2 +-
 core/src/test/java/fj/data/hamt/HamtTest.java             | 2 +-
 core/src/test/java/fj/data/optic/IsoTest.java             | 2 +-
 core/src/test/java/fj/data/optic/LensTest.java            | 2 +-
 core/src/test/java/fj/data/optic/OptionalTest.java        | 2 +-
 core/src/test/java/fj/data/optic/PrismTest.java           | 2 +-
 core/src/test/java/fj/data/optic/TraversalTest.java       | 2 +-
 core/src/test/java/fj/data/vector/VTest.java              | 2 +-
 core/src/test/java/fj/function/VisitorTest.java           | 2 +-
 props-core/src/test/java/fj/data/ReaderTest.java          | 2 +-
 .../src/test/java/fj/data/fingertrees/FingerTreeTest.java | 3 +--
 .../java/fj/data/properties/PriorityQueueProperties.java  | 2 +-
 28 files changed, 31 insertions(+), 32 deletions(-)

diff --git a/build.gradle b/build.gradle
index 70485ec9..93dafa67 100644
--- a/build.gradle
+++ b/build.gradle
@@ -11,7 +11,7 @@ buildscript {
     }
 
     dependencies {
-        classpath "com.github.ben-manes:gradle-versions-plugin:0.27.0"
+        classpath "com.github.ben-manes:gradle-versions-plugin:0.36.0"
         classpath "biz.aQute.bnd:biz.aQute.bnd.gradle:5.3.0"
     }
 
@@ -46,7 +46,7 @@ allprojects {
 
         snapshotAppendix = "-SNAPSHOT"
 		fjVersion = fjBaseVersion + (isSnapshot ? snapshotAppendix : "")
-        fjConsumeVersion = "4.9"
+        fjConsumeVersion = "5.0"
 
         signModule = false
 
@@ -66,8 +66,8 @@ allprojects {
         sonatypeUploadUrl = isSnapshot ? sonatypeSnapshotUrl : sonatypeReleaseUrl
         primaryEmail = "functionaljava@googlegroups.com"
 
-        junitCompile = "junit:junit:4.12"
-        junitRuntime = "org.junit.vintage:junit-vintage-engine:5.5.2"
+        junitCompile = "junit:junit:4.13.2"
+        junitRuntime = "org.junit.vintage:junit-vintage-engine:5.8.2"
 
         displayCompilerWarnings = true
         generateTestReports = false
diff --git a/core/src/test/java/fj/ClassTest.java b/core/src/test/java/fj/ClassTest.java
index 2959e351..dfbc7f00 100644
--- a/core/src/test/java/fj/ClassTest.java
+++ b/core/src/test/java/fj/ClassTest.java
@@ -11,7 +11,7 @@
 import java.util.Iterator;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ClassTest {
     @Test
diff --git a/core/src/test/java/fj/DigitTest.java b/core/src/test/java/fj/DigitTest.java
index 9fc98d4c..13169aca 100644
--- a/core/src/test/java/fj/DigitTest.java
+++ b/core/src/test/java/fj/DigitTest.java
@@ -5,7 +5,7 @@
 
 import static fj.data.Array.range;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class DigitTest {
     @Test
diff --git a/core/src/test/java/fj/MonoidTest.java b/core/src/test/java/fj/MonoidTest.java
index 1156e729..68457f09 100644
--- a/core/src/test/java/fj/MonoidTest.java
+++ b/core/src/test/java/fj/MonoidTest.java
@@ -8,7 +8,7 @@
 
 import static fj.data.Option.some;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class MonoidTest {
 
diff --git a/core/src/test/java/fj/TryTest.java b/core/src/test/java/fj/TryTest.java
index bd94e986..46fb2dd3 100644
--- a/core/src/test/java/fj/TryTest.java
+++ b/core/src/test/java/fj/TryTest.java
@@ -5,7 +5,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TryTest {
 
diff --git a/core/src/test/java/fj/control/db/TestDbState.java b/core/src/test/java/fj/control/db/TestDbState.java
index 188eae3d..2a942e1a 100644
--- a/core/src/test/java/fj/control/db/TestDbState.java
+++ b/core/src/test/java/fj/control/db/TestDbState.java
@@ -9,7 +9,7 @@
 import java.sql.*;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TestDbState {
     @Test
diff --git a/core/src/test/java/fj/data/ArrayTest.java b/core/src/test/java/fj/data/ArrayTest.java
index 5713e5c3..e686a02b 100644
--- a/core/src/test/java/fj/data/ArrayTest.java
+++ b/core/src/test/java/fj/data/ArrayTest.java
@@ -5,7 +5,7 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ArrayTest {
 
diff --git a/core/src/test/java/fj/data/DListTest.java b/core/src/test/java/fj/data/DListTest.java
index 6846ca2d..48c0c2fe 100644
--- a/core/src/test/java/fj/data/DListTest.java
+++ b/core/src/test/java/fj/data/DListTest.java
@@ -4,7 +4,7 @@
 
 import static fj.data.DList.*;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class DListTest {
     @Test
diff --git a/core/src/test/java/fj/data/LazyStringTest.java b/core/src/test/java/fj/data/LazyStringTest.java
index 1adef2bd..14a88c14 100644
--- a/core/src/test/java/fj/data/LazyStringTest.java
+++ b/core/src/test/java/fj/data/LazyStringTest.java
@@ -4,7 +4,7 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class LazyStringTest {
 
diff --git a/core/src/test/java/fj/data/ListBufferTest.java b/core/src/test/java/fj/data/ListBufferTest.java
index f2ed8286..6b16f1ca 100644
--- a/core/src/test/java/fj/data/ListBufferTest.java
+++ b/core/src/test/java/fj/data/ListBufferTest.java
@@ -3,7 +3,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ListBufferTest {
 
diff --git a/core/src/test/java/fj/data/SetTest.java b/core/src/test/java/fj/data/SetTest.java
index ae65b687..e30d166a 100644
--- a/core/src/test/java/fj/data/SetTest.java
+++ b/core/src/test/java/fj/data/SetTest.java
@@ -6,7 +6,7 @@
 import static fj.data.Option.some;
 import static fj.Ord.intOrd;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class SetTest {
 
diff --git a/core/src/test/java/fj/data/StreamTest.java b/core/src/test/java/fj/data/StreamTest.java
index f320f27a..febd4567 100644
--- a/core/src/test/java/fj/data/StreamTest.java
+++ b/core/src/test/java/fj/data/StreamTest.java
@@ -36,7 +36,7 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class StreamTest {
 
diff --git a/core/src/test/java/fj/data/TreeMapTest.java b/core/src/test/java/fj/data/TreeMapTest.java
index 77352989..051f0773 100644
--- a/core/src/test/java/fj/data/TreeMapTest.java
+++ b/core/src/test/java/fj/data/TreeMapTest.java
@@ -16,7 +16,7 @@
 import static fj.data.TreeMap.iterableTreeMap;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 public class TreeMapTest {
diff --git a/core/src/test/java/fj/data/TreeTest.java b/core/src/test/java/fj/data/TreeTest.java
index fd43c852..a6028f37 100644
--- a/core/src/test/java/fj/data/TreeTest.java
+++ b/core/src/test/java/fj/data/TreeTest.java
@@ -4,7 +4,7 @@
 
 import static fj.data.Tree.leaf;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TreeTest {
 
diff --git a/core/src/test/java/fj/data/TreeZipperTest.java b/core/src/test/java/fj/data/TreeZipperTest.java
index c52f4111..c2549963 100644
--- a/core/src/test/java/fj/data/TreeZipperTest.java
+++ b/core/src/test/java/fj/data/TreeZipperTest.java
@@ -4,7 +4,7 @@
 
 import static fj.data.Option.none;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TreeZipperTest {
     @Test
diff --git a/core/src/test/java/fj/data/ValidationTest.java b/core/src/test/java/fj/data/ValidationTest.java
index 37a51bcc..4505499c 100644
--- a/core/src/test/java/fj/data/ValidationTest.java
+++ b/core/src/test/java/fj/data/ValidationTest.java
@@ -37,7 +37,7 @@
 import static fj.data.Validation.*;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 
 public class ValidationTest {
diff --git a/core/src/test/java/fj/data/ZipperTest.java b/core/src/test/java/fj/data/ZipperTest.java
index 51c7b4ea..78d837aa 100644
--- a/core/src/test/java/fj/data/ZipperTest.java
+++ b/core/src/test/java/fj/data/ZipperTest.java
@@ -3,7 +3,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ZipperTest {
     @Test
diff --git a/core/src/test/java/fj/data/hamt/HamtTest.java b/core/src/test/java/fj/data/hamt/HamtTest.java
index 1e601f24..19a22411 100644
--- a/core/src/test/java/fj/data/hamt/HamtTest.java
+++ b/core/src/test/java/fj/data/hamt/HamtTest.java
@@ -12,7 +12,7 @@
 import static fj.P.p;
 import static fj.data.List.list;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 /**
  * @author Mark Perry
diff --git a/core/src/test/java/fj/data/optic/IsoTest.java b/core/src/test/java/fj/data/optic/IsoTest.java
index 6cace533..7aace4d8 100644
--- a/core/src/test/java/fj/data/optic/IsoTest.java
+++ b/core/src/test/java/fj/data/optic/IsoTest.java
@@ -5,7 +5,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class IsoTest {
     @Test
diff --git a/core/src/test/java/fj/data/optic/LensTest.java b/core/src/test/java/fj/data/optic/LensTest.java
index d78fa0d0..60513651 100644
--- a/core/src/test/java/fj/data/optic/LensTest.java
+++ b/core/src/test/java/fj/data/optic/LensTest.java
@@ -4,7 +4,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class LensTest {
     @Test
diff --git a/core/src/test/java/fj/data/optic/OptionalTest.java b/core/src/test/java/fj/data/optic/OptionalTest.java
index 07c3f79a..5bea2864 100644
--- a/core/src/test/java/fj/data/optic/OptionalTest.java
+++ b/core/src/test/java/fj/data/optic/OptionalTest.java
@@ -4,7 +4,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class OptionalTest {
     @Test
diff --git a/core/src/test/java/fj/data/optic/PrismTest.java b/core/src/test/java/fj/data/optic/PrismTest.java
index da128d72..ce6dddb4 100644
--- a/core/src/test/java/fj/data/optic/PrismTest.java
+++ b/core/src/test/java/fj/data/optic/PrismTest.java
@@ -4,7 +4,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class PrismTest {
     @Test
diff --git a/core/src/test/java/fj/data/optic/TraversalTest.java b/core/src/test/java/fj/data/optic/TraversalTest.java
index cadd6ccf..9cfc25cc 100644
--- a/core/src/test/java/fj/data/optic/TraversalTest.java
+++ b/core/src/test/java/fj/data/optic/TraversalTest.java
@@ -5,7 +5,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TraversalTest {
     @Test
diff --git a/core/src/test/java/fj/data/vector/VTest.java b/core/src/test/java/fj/data/vector/VTest.java
index 9a3709ac..8dabd66e 100644
--- a/core/src/test/java/fj/data/vector/VTest.java
+++ b/core/src/test/java/fj/data/vector/VTest.java
@@ -5,7 +5,7 @@
 import org.junit.Test;
 
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class VTest {
     @Test
diff --git a/core/src/test/java/fj/function/VisitorTest.java b/core/src/test/java/fj/function/VisitorTest.java
index 54efcf24..da92a4bb 100644
--- a/core/src/test/java/fj/function/VisitorTest.java
+++ b/core/src/test/java/fj/function/VisitorTest.java
@@ -11,7 +11,7 @@
 import static fj.data.Option.some;
 import static fj.function.Visitor.*;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class VisitorTest {
     @Test
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index accc3394..4817e41c 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -10,7 +10,7 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 public class ReaderTest {
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index a26fdc89..7f02288c 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -8,10 +8,9 @@
 import org.junit.Test;
 
 import static fj.Monoid.intAdditionMonoid;
-import static fj.Monoid.intMinMonoid;
 import static fj.data.fingertrees.FingerTree.measured;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
 public class FingerTreeTest {
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
index c2e46eca..5460bfdf 100644
--- a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
+++ b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -24,7 +24,7 @@
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 @RunWith(PropertyTestRunner.class)
 @CheckParams(maxSize = 100)

From c4ebbb541a40bcbf8a17e6ef1f1cae7a3a463ff4 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 14 Feb 2022 22:22:45 +1000
Subject: [PATCH 324/336] Updated bnd to 6.1.0

---
 build.gradle | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 93dafa67..3b627e85 100644
--- a/build.gradle
+++ b/build.gradle
@@ -12,7 +12,7 @@ buildscript {
 
     dependencies {
         classpath "com.github.ben-manes:gradle-versions-plugin:0.36.0"
-        classpath "biz.aQute.bnd:biz.aQute.bnd.gradle:5.3.0"
+        classpath "biz.aQute.bnd:biz.aQute.bnd.gradle:6.1.0"
     }
 
     wrapper {

From df6e6f8ea2fee836794c365f93fc8839388fd02b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 14 Feb 2022 22:49:54 +1000
Subject: [PATCH 325/336] Updated H2 lib to 2.1.210.  Updated deprecated
 Assert.assertThat to MatcherAssert.assertThat

---
 core/build.gradle                                     |  2 +-
 core/src/test/java/fj/FFunctionsTest.java             |  2 +-
 core/src/test/java/fj/OrderingTest.java               |  2 +-
 core/src/test/java/fj/PTest.java                      |  2 +-
 core/src/test/java/fj/TryEffectTest.java              |  2 +-
 .../test/java/fj/control/parallel/StrategyTest.java   |  3 ++-
 core/src/test/java/fj/data/BooleansTest.java          |  3 ++-
 core/src/test/java/fj/data/IOFunctionsTest.java       | 11 ++++++-----
 core/src/test/java/fj/data/ListTest.java              |  5 ++++-
 core/src/test/java/fj/data/List_Traverse_Tests.java   |  2 +-
 core/src/test/java/fj/function/DoublesTest.java       |  5 ++++-
 core/src/test/java/fj/function/IntegersTest.java      |  5 ++++-
 core/src/test/java/fj/function/LongsTest.java         |  5 ++++-
 core/src/test/java/fj/function/StringsTest.java       |  2 +-
 core/src/test/java/fj/parser/ParserTest.java          |  2 +-
 15 files changed, 34 insertions(+), 19 deletions(-)

diff --git a/core/build.gradle b/core/build.gradle
index cbdad60b..9ee293a9 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -8,7 +8,7 @@ archivesBaseName = project.projectName
 dependencies {
     testCompile junitCompile
     testRuntime junitRuntime
-    testCompile 'com.h2database:h2:1.4.199'
+    testCompile 'com.h2database:h2:2.1.210'
     testCompile 'commons-dbutils:commons-dbutils:1.7'
 }
 
diff --git a/core/src/test/java/fj/FFunctionsTest.java b/core/src/test/java/fj/FFunctionsTest.java
index b235ff67..4f01a0db 100644
--- a/core/src/test/java/fj/FFunctionsTest.java
+++ b/core/src/test/java/fj/FFunctionsTest.java
@@ -4,7 +4,7 @@
 import fj.data.TreeZipper;
 import org.junit.Test;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class FFunctionsTest {
 
diff --git a/core/src/test/java/fj/OrderingTest.java b/core/src/test/java/fj/OrderingTest.java
index 9b980e67..640bc1d3 100644
--- a/core/src/test/java/fj/OrderingTest.java
+++ b/core/src/test/java/fj/OrderingTest.java
@@ -8,7 +8,7 @@
 import static fj.Ordering.GT;
 import static fj.Ordering.LT;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class OrderingTest {
 
diff --git a/core/src/test/java/fj/PTest.java b/core/src/test/java/fj/PTest.java
index 2a97303f..00220f9d 100644
--- a/core/src/test/java/fj/PTest.java
+++ b/core/src/test/java/fj/PTest.java
@@ -4,7 +4,7 @@
 
 import static fj.Function.identity;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class PTest {
     @Test
diff --git a/core/src/test/java/fj/TryEffectTest.java b/core/src/test/java/fj/TryEffectTest.java
index ea92b8f2..6fd46fd1 100644
--- a/core/src/test/java/fj/TryEffectTest.java
+++ b/core/src/test/java/fj/TryEffectTest.java
@@ -5,7 +5,7 @@
 import fj.function.TryEffect1;
 import org.junit.Test;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class TryEffectTest {
 
diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
index 0c605829..b4d21320 100644
--- a/core/src/test/java/fj/control/parallel/StrategyTest.java
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -16,7 +16,8 @@
 import static fj.control.parallel.Strategy.*;
 import static fj.data.Stream.range;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
+
 
 public class StrategyTest {
 
diff --git a/core/src/test/java/fj/data/BooleansTest.java b/core/src/test/java/fj/data/BooleansTest.java
index 84f7676f..61325df0 100644
--- a/core/src/test/java/fj/data/BooleansTest.java
+++ b/core/src/test/java/fj/data/BooleansTest.java
@@ -9,6 +9,7 @@
 import static fj.data.List.list;
 import static fj.function.Booleans.isnot;
 import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class BooleansTest {
 
@@ -70,7 +71,7 @@ public void testIsNot(){
         F<Integer, Boolean> f1 = a -> a == 4;
         List<String> result = list("some", "come", "done!").filter(isnot(String::length, f1));
 
-        Assert.assertThat(result.length(), is(1));
+        assertThat(result.length(), is(1));
         Assert.assertEquals(result, list("done!"));
 
     }
diff --git a/core/src/test/java/fj/data/IOFunctionsTest.java b/core/src/test/java/fj/data/IOFunctionsTest.java
index adad0d11..8ae18b1a 100644
--- a/core/src/test/java/fj/data/IOFunctionsTest.java
+++ b/core/src/test/java/fj/data/IOFunctionsTest.java
@@ -12,7 +12,8 @@
 import static fj.data.Stream.cons;
 import static fj.data.Stream.nil_;
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
 
 public class IOFunctionsTest {
 
@@ -33,8 +34,8 @@ public void close() {
         r -> () -> new BufferedReader(r).readLine()
     );
 
-    Assert.assertThat(bracketed.run(), is("Read OK"));
-    Assert.assertThat(closed.get(), is(true));
+    assertThat(bracketed.run(), is("Read OK"));
+    assertThat(closed.get(), is(true));
   }
 
   @Test
@@ -59,9 +60,9 @@ public void close() {
       bracketed.run();
       fail("Exception expected");
     } catch (IllegalArgumentException e) {
-      Assert.assertThat(e.getMessage(), is("OoO"));
+      assertThat(e.getMessage(), is("OoO"));
     }
-    Assert.assertThat(closed.get(), is(true));
+    assertThat(closed.get(), is(true));
   }
 
   @Test
diff --git a/core/src/test/java/fj/data/ListTest.java b/core/src/test/java/fj/data/ListTest.java
index 9f09de0f..720157e8 100644
--- a/core/src/test/java/fj/data/ListTest.java
+++ b/core/src/test/java/fj/data/ListTest.java
@@ -30,7 +30,10 @@
 import static fj.data.Validation.fail;
 import static fj.data.Validation.*;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
 
 public class ListTest {
 
diff --git a/core/src/test/java/fj/data/List_Traverse_Tests.java b/core/src/test/java/fj/data/List_Traverse_Tests.java
index 5b7c0d19..ad925847 100644
--- a/core/src/test/java/fj/data/List_Traverse_Tests.java
+++ b/core/src/test/java/fj/data/List_Traverse_Tests.java
@@ -7,7 +7,7 @@
 import static fj.data.List.list;
 import static fj.data.Option.some;
 import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class List_Traverse_Tests {
 
diff --git a/core/src/test/java/fj/function/DoublesTest.java b/core/src/test/java/fj/function/DoublesTest.java
index 6ba98fa2..09ca4bbe 100644
--- a/core/src/test/java/fj/function/DoublesTest.java
+++ b/core/src/test/java/fj/function/DoublesTest.java
@@ -1,6 +1,9 @@
 package fj.function;
 
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 
 import fj.F;
 import org.junit.Test;
diff --git a/core/src/test/java/fj/function/IntegersTest.java b/core/src/test/java/fj/function/IntegersTest.java
index 985afba9..c07197af 100644
--- a/core/src/test/java/fj/function/IntegersTest.java
+++ b/core/src/test/java/fj/function/IntegersTest.java
@@ -8,7 +8,10 @@
 import static fj.data.List.list;
 import static fj.data.Option.none;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+import static org.junit.Assert.assertTrue;
 
 public class IntegersTest {
 
diff --git a/core/src/test/java/fj/function/LongsTest.java b/core/src/test/java/fj/function/LongsTest.java
index d59fc07c..196da20f 100644
--- a/core/src/test/java/fj/function/LongsTest.java
+++ b/core/src/test/java/fj/function/LongsTest.java
@@ -8,7 +8,10 @@
 import static fj.data.List.list;
 import static fj.data.Option.none;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 
 public class LongsTest {
 
diff --git a/core/src/test/java/fj/function/StringsTest.java b/core/src/test/java/fj/function/StringsTest.java
index c13e1b81..79cb8a3d 100644
--- a/core/src/test/java/fj/function/StringsTest.java
+++ b/core/src/test/java/fj/function/StringsTest.java
@@ -5,7 +5,7 @@
 
 import static fj.Function.compose;
 import static fj.function.Strings.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
 
 public class StringsTest {
diff --git a/core/src/test/java/fj/parser/ParserTest.java b/core/src/test/java/fj/parser/ParserTest.java
index a3f623f5..f2664a1f 100644
--- a/core/src/test/java/fj/parser/ParserTest.java
+++ b/core/src/test/java/fj/parser/ParserTest.java
@@ -8,7 +8,7 @@
 
 import static fj.parser.Result.result;
 import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class ParserTest {
     @Test

From 5ecd37c0b30b383ed8788b62190b4efce6b0feab Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 14 Feb 2022 23:54:44 +1000
Subject: [PATCH 326/336] Upgrade Gradle to 7.3, jacoco to 0.8.7.  Upgrade
 plugin from java to java-library, maven to maven-publish

---
 build.gradle                                  |  19 ++-
 consume/build.gradle                          |   6 +-
 core/build.gradle                             |  14 +-
 .../fj/control/parallel/StrategyTest.java     |   1 -
 core/src/test/java/fj/data/ArrayTest.java     |   1 +
 core/src/test/java/fj/data/BooleansTest.java  |   1 +
 core/src/test/java/fj/data/DListTest.java     |   1 +
 .../src/test/java/fj/data/LazyStringTest.java |   1 +
 .../src/test/java/fj/data/ListBufferTest.java |   1 +
 .../java/fj/data/List_Traverse_Tests.java     |   1 +
 core/src/test/java/fj/data/hamt/HamtTest.java |   1 +
 core/src/test/java/fj/data/optic/IsoTest.java |   1 +
 .../src/test/java/fj/data/optic/LensTest.java |   1 +
 .../test/java/fj/data/optic/OptionalTest.java |   1 +
 core/src/test/java/fj/data/vector/VTest.java  |   1 +
 .../test/java/fj/function/DoublesTest.java    |   2 +-
 .../test/java/fj/function/StringsTest.java    |   4 +-
 demo/build.gradle                             |   8 +-
 gradle/wrapper/gradle-wrapper.properties      |   2 +-
 java-core/build.gradle                        |  11 +-
 lib.gradle                                    | 138 +++++++++++++-----
 performance/build.gradle                      |   6 +-
 props-core-scalacheck/build.gradle            |  12 +-
 props-core/build.gradle                       |   6 +-
 .../src/test/java/fj/data/ReaderTest.java     |   1 +
 .../fj/data/fingertrees/FingerTreeTest.java   |   3 +-
 quickcheck/build.gradle                       |   9 +-
 27 files changed, 173 insertions(+), 80 deletions(-)

diff --git a/build.gradle b/build.gradle
index 3b627e85..9556b473 100644
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "6.8.3"
+        gradleVersion = "7.3"
         distributionType = Wrapper.DistributionType.ALL
     }
 }
@@ -35,7 +35,7 @@ allprojects {
     apply plugin: "jacoco"
 
     jacoco {
-        toolVersion = "0.8.2"
+        toolVersion = "0.8.7"
     }
 
 	defaultTasks "build"
@@ -49,6 +49,7 @@ allprojects {
         fjConsumeVersion = "5.0"
 
         signModule = false
+        uploadModule = false
 
         projectTitle = "Functional Java"
 		projectName = "functionaljava"
@@ -58,12 +59,20 @@ allprojects {
         projectUrl = "http://functionaljava.org/"
         scmUrl = "git://github.com/functionaljava/functionaljava.git"
         scmGitFile = "scm:git@github.com:functionaljava/functionaljava.git"
+        scmSshGitFile = "scm:git:ssh://git@github.com/functionaljava/functionaljava.git"
+        licenseUrl = "https://github.com/functionaljava/functionaljava/blob/master/etc/LICENCE"
+        licenseName = "The BSD3 License"
+
+        issueUrl = "https://github.com/functionaljava/functionaljava/issues"
+        githubUrl = "https://github.com/functionaljava/functionaljava"
 
         sonatypeBaseUrl = "https://oss.sonatype.org"
         sonatypeSnapshotUrl = "$sonatypeBaseUrl/content/repositories/snapshots/"
         sonatypeRepositoryUrl = "$sonatypeBaseUrl/content/groups/public"
         sonatypeReleaseUrl = "$sonatypeBaseUrl/service/local/staging/deploy/maven2/"
+
         sonatypeUploadUrl = isSnapshot ? sonatypeSnapshotUrl : sonatypeReleaseUrl
+
         primaryEmail = "functionaljava@googlegroups.com"
 
         junitCompile = "junit:junit:4.13.2"
@@ -94,7 +103,7 @@ subprojects {
     }
 
     apply from: "$rootDir/lib.gradle"
-	apply plugin: "java"
+	apply plugin: "java-library"
 	apply plugin: "eclipse"
 
 	repositories {
@@ -139,7 +148,7 @@ task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
 
 configure(subprojects.findAll { it.name != "props-core" }) {
 
-    apply plugin: "maven"
+    apply plugin: "maven-publish"
     apply plugin: "signing"
     apply plugin: "biz.aQute.bnd.builder"
     sourceCompatibility = "1.8"
@@ -164,7 +173,7 @@ configure(subprojects.findAll { it.name != "props-core" }) {
     }
 
     jar {
-        version project.fjVersion
+        archiveVersion = project.fjVersion
         bnd (
                 'Bundle-Name': 'Functional Java',
                 'Signature-Version': project.fjVersion,
diff --git a/consume/build.gradle b/consume/build.gradle
index 370ebfbf..45dadefb 100644
--- a/consume/build.gradle
+++ b/consume/build.gradle
@@ -2,8 +2,8 @@
 archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
-    compile("$group:$projectName:$fjConsumeVersion")
+    api "$group:$projectName:$fjConsumeVersion"
 
-    testCompile junitCompile
-    testRuntime junitRuntime
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
 }
diff --git a/core/build.gradle b/core/build.gradle
index 9ee293a9..282ec191 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -1,18 +1,18 @@
 
 ext {
     signModule = true
+    uploadModule = true
+
 }
 
 archivesBaseName = project.projectName
 
 dependencies {
-    testCompile junitCompile
-    testRuntime junitRuntime
-    testCompile 'com.h2database:h2:2.1.210'
-    testCompile 'commons-dbutils:commons-dbutils:1.7'
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
+    testImplementation 'com.h2database:h2:2.1.210'
+    testImplementation 'commons-dbutils:commons-dbutils:1.7'
 }
 
 performSigning(signingEnabled, signModule)
-configureUpload(signingEnabled, signModule)
-
-uploadArchives.enabled = true
+configureUpload(signingEnabled, signModule, uploadModule)
diff --git a/core/src/test/java/fj/control/parallel/StrategyTest.java b/core/src/test/java/fj/control/parallel/StrategyTest.java
index b4d21320..1f5e7bba 100644
--- a/core/src/test/java/fj/control/parallel/StrategyTest.java
+++ b/core/src/test/java/fj/control/parallel/StrategyTest.java
@@ -18,7 +18,6 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
-
 public class StrategyTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/ArrayTest.java b/core/src/test/java/fj/data/ArrayTest.java
index e686a02b..11683fbf 100644
--- a/core/src/test/java/fj/data/ArrayTest.java
+++ b/core/src/test/java/fj/data/ArrayTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class ArrayTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/BooleansTest.java b/core/src/test/java/fj/data/BooleansTest.java
index 61325df0..e5dbeb12 100644
--- a/core/src/test/java/fj/data/BooleansTest.java
+++ b/core/src/test/java/fj/data/BooleansTest.java
@@ -11,6 +11,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class BooleansTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/DListTest.java b/core/src/test/java/fj/data/DListTest.java
index 48c0c2fe..77f4db6c 100644
--- a/core/src/test/java/fj/data/DListTest.java
+++ b/core/src/test/java/fj/data/DListTest.java
@@ -6,6 +6,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class DListTest {
     @Test
     public void testConsSnoc() {
diff --git a/core/src/test/java/fj/data/LazyStringTest.java b/core/src/test/java/fj/data/LazyStringTest.java
index 14a88c14..060c5394 100644
--- a/core/src/test/java/fj/data/LazyStringTest.java
+++ b/core/src/test/java/fj/data/LazyStringTest.java
@@ -6,6 +6,7 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class LazyStringTest {
 
     @Test
diff --git a/core/src/test/java/fj/data/ListBufferTest.java b/core/src/test/java/fj/data/ListBufferTest.java
index 6b16f1ca..784b9510 100644
--- a/core/src/test/java/fj/data/ListBufferTest.java
+++ b/core/src/test/java/fj/data/ListBufferTest.java
@@ -5,6 +5,7 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class ListBufferTest {
 
 	@Test
diff --git a/core/src/test/java/fj/data/List_Traverse_Tests.java b/core/src/test/java/fj/data/List_Traverse_Tests.java
index ad925847..eee5752d 100644
--- a/core/src/test/java/fj/data/List_Traverse_Tests.java
+++ b/core/src/test/java/fj/data/List_Traverse_Tests.java
@@ -9,6 +9,7 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class List_Traverse_Tests {
 
     @Test
diff --git a/core/src/test/java/fj/data/hamt/HamtTest.java b/core/src/test/java/fj/data/hamt/HamtTest.java
index 19a22411..ce901e6e 100644
--- a/core/src/test/java/fj/data/hamt/HamtTest.java
+++ b/core/src/test/java/fj/data/hamt/HamtTest.java
@@ -14,6 +14,7 @@
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 /**
  * @author Mark Perry
  */
diff --git a/core/src/test/java/fj/data/optic/IsoTest.java b/core/src/test/java/fj/data/optic/IsoTest.java
index 7aace4d8..f9559d3f 100644
--- a/core/src/test/java/fj/data/optic/IsoTest.java
+++ b/core/src/test/java/fj/data/optic/IsoTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class IsoTest {
     @Test
     public void testIso() {
diff --git a/core/src/test/java/fj/data/optic/LensTest.java b/core/src/test/java/fj/data/optic/LensTest.java
index 60513651..98be7fca 100644
--- a/core/src/test/java/fj/data/optic/LensTest.java
+++ b/core/src/test/java/fj/data/optic/LensTest.java
@@ -6,6 +6,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class LensTest {
     @Test
     public void testLensPersonGet() {
diff --git a/core/src/test/java/fj/data/optic/OptionalTest.java b/core/src/test/java/fj/data/optic/OptionalTest.java
index 5bea2864..7fddb31b 100644
--- a/core/src/test/java/fj/data/optic/OptionalTest.java
+++ b/core/src/test/java/fj/data/optic/OptionalTest.java
@@ -6,6 +6,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class OptionalTest {
     @Test
     public void testOptionalSome() {
diff --git a/core/src/test/java/fj/data/vector/VTest.java b/core/src/test/java/fj/data/vector/VTest.java
index 8dabd66e..34f8686c 100644
--- a/core/src/test/java/fj/data/vector/VTest.java
+++ b/core/src/test/java/fj/data/vector/VTest.java
@@ -7,6 +7,7 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+
 public class VTest {
     @Test
     public void testVectorUp(){
diff --git a/core/src/test/java/fj/function/DoublesTest.java b/core/src/test/java/fj/function/DoublesTest.java
index 09ca4bbe..53b74e52 100644
--- a/core/src/test/java/fj/function/DoublesTest.java
+++ b/core/src/test/java/fj/function/DoublesTest.java
@@ -1,7 +1,6 @@
 package fj.function;
 
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 
@@ -12,6 +11,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
+import static org.junit.Assert.assertTrue;
 import static org.hamcrest.core.Is.is;
 
 import static fj.data.List.list;
diff --git a/core/src/test/java/fj/function/StringsTest.java b/core/src/test/java/fj/function/StringsTest.java
index 79cb8a3d..db20fd68 100644
--- a/core/src/test/java/fj/function/StringsTest.java
+++ b/core/src/test/java/fj/function/StringsTest.java
@@ -5,8 +5,10 @@
 
 import static fj.Function.compose;
 import static fj.function.Strings.*;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.*;
 import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
 
 public class StringsTest {
     @Test
diff --git a/demo/build.gradle b/demo/build.gradle
index f19e765f..87bf7a5c 100644
--- a/demo/build.gradle
+++ b/demo/build.gradle
@@ -6,10 +6,10 @@ mainClassName = "fj.demo.euler.Problem2"
 archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
-    compile project(":core")
-    compile project(":quickcheck")
-    testCompile junitCompile
-    testRuntime junitRuntime
+    api project(":core")
+    api project(":quickcheck")
+    testImplementation junitCompile
+    testImplementation junitRuntime
 }
 
 test {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 8cf6eb5a..fbce071a 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/java-core/build.gradle b/java-core/build.gradle
index e7b40bb9..f6a6146a 100644
--- a/java-core/build.gradle
+++ b/java-core/build.gradle
@@ -3,16 +3,15 @@ archivesBaseName = "${project.projectName}-${project.name}"
 
 ext {
     signModule = true
+    uploadModule = true
 }
 
 dependencies {
-    compile project(":core")
-    testCompile junitCompile
-    testRuntime junitRuntime
+    api project(":core")
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
 }
 
 performSigning(signingEnabled, signModule)
-configureUpload(signingEnabled, signModule)
+configureUpload(signingEnabled, signModule, uploadModule)
 
-
-uploadArchives.enabled = true
diff --git a/lib.gradle b/lib.gradle
index 39ce7a7e..5ff91f01 100644
--- a/lib.gradle
+++ b/lib.gradle
@@ -20,7 +20,7 @@ String findJavaCommand(String command) {
 
 Boolean doSigning(String signingAllowed, Boolean doModule) {
     def b = signingAllowed.trim() == "true" && doModule
-//    println("signModule: ${project.name} signingEnabled: $signingAllowed module: $doModule")
+//    println("signModule: ${project.name} signingAllowed: $signingAllowed doModule: $doModule")
     b
 }
 
@@ -31,50 +31,122 @@ void performSigning(String signingAllowed, Boolean doModule) {
     }
 }
 
-void configureUpload(String signingEnabled, Boolean signModule) {
+def customisePom(pom, gradleProject) {
+    pom.withXml {
+        def root = asNode()
 
-    uploadArchives {
-        enabled = false
-        repositories {
-            mavenDeployer {
-                if (doSigning(signingEnabled, signModule)) {
-                    beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
-                }
+        // add all items necessary for maven central publication
+        root.children().last() + {
+            resolveStrategy = Closure.DELEGATE_FIRST
 
-                repository(url: sonatypeUploadUrl) {
-                    authentication(userName: sonatypeUsername, password: sonatypePassword)
+            name project.pomProjectName
+            description project.projectDescription
+            url project.projectUrl
+            organization {
+                name project.pomOrganisation
+                url project.projectUrl
+            }
+            issueManagement {
+                system 'GitHub'
+                url project.issueUrl
+            }
+            licenses {
+                license {
+                    name project.licenseName
+                    url project.licenseUrl
+                    distribution 'repo'
                 }
-                pom {
-                    groupId = project.group
-                    project {
-                        name pomProjectName
-                        packaging 'jar'
-                        description projectDescription
-                        url projectUrl
-                        organization {
-                            name pomOrganisation
-                            url projectUrl
-                        }
-                        scm {
-                            url scmUrl
-                        }
-                        licenses {
-                            license {
-                                name "The BSD3 License"
-                                url "https://github.com/functionaljava/functionaljava/blob/master/etc/LICENCE"
-                                distribution 'repo'
+            }
+            scm {
+                url project.githubUrl
+                connection project.scmGitFile
+                developerConnection project.scmSshGitFile
+            }
+        }
+    }
+}
+
+
+void configureUpload(String signingEnabled, Boolean signModule, Boolean uploadModule) {
+
+    if (uploadModule) {
+
+        publishing {
+
+            publications {
+
+                mavenJava(MavenPublication) {
+                    groupId project.group
+                    artifactId project.name
+                    version project.version
+
+                    from components.java
+
+                    customisePom(pom, rootProject)
+
+                    artifact sourcesJar
+                    artifact javadocJar
+
+                    if (doSigning(signingEnabled, signModule)) {
+                        // sign the pom
+                        pom.withXml {
+                            def pomFile = file("${project.buildDir}/generated-pom.xml.asc")
+                            writeTo(pomFile)
+                            def pomAscFile = signing.sign(pomFile).signatureFiles[0]
+                            artifact(pomAscFile) {
+                                classifier = null
+                                extension = 'pom.asc'
                             }
+                            pomFile.delete()
                         }
-                        developers {
-                            developer {
-                                email primaryEmail
+
+                        // sign the artifacts
+                        project.tasks.signArchives.signatureFiles.each {
+                            artifact(it) {
+                                def matcher = it.file =~ /-(sources|javadoc|jre8|jre9)\.jar\.asc$/
+                                if (matcher.find()) {
+                                    classifier = matcher.group(1)
+                                } else {
+                                    classifier = null
+                                }
+                                extension = 'jar.asc'
                             }
                         }
                     }
+
+                }
+
+            }
+
+            repositories {
+                maven {
+                    url project.sonatypeUploadUrl
+                    credentials {
+                        username sonatypeUsername
+                        password sonatypePassword
+                    }
                 }
             }
+
+        }
+
+        model {
+            tasks.publishMavenJavaPublicationToMavenLocal {
+                dependsOn(project.tasks.signArchives)
+            }
+            tasks.publishMavenJavaPublicationToMavenRepository {
+                dependsOn(project.tasks.signArchives)
+            }
+            tasks.publish {
+                dependsOn(project.tasks.build)
+            }
+//        tasks.install {
+//            dependsOn(project.tasks.build)
+//        }
         }
+
     }
+
 }
 
 ext {
diff --git a/performance/build.gradle b/performance/build.gradle
index c6f4c8a6..7efbde2e 100644
--- a/performance/build.gradle
+++ b/performance/build.gradle
@@ -1,6 +1,6 @@
 
 dependencies {
-    compile project(":core")
-    testCompile junitCompile
-    testRuntime junitRuntime
+    api project(":core")
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
 }
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index f26b5425..358b365b 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -11,12 +11,12 @@ ext {
 }
 
 dependencies {
-    compile project(":core")
-    compile "org.scala-lang:scala-library:$scalaVersion"
-    compile "org.scalacheck:scalacheck_$scalacheckScalaVersion:$scalacheckVersion"
+    api project(":core")
+    api "org.scala-lang:scala-library:$scalaVersion"
+    api "org.scalacheck:scalacheck_$scalacheckScalaVersion:$scalacheckVersion"
 
-    testCompile junitCompile
-    testRuntime junitRuntime
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
 }
 
 tasks.withType(ScalaCompile) {
@@ -24,4 +24,4 @@ tasks.withType(ScalaCompile) {
 }
 
 performSigning(signingEnabled, signModule)
-configureUpload(signingEnabled, signModule)
+configureUpload(signingEnabled, signModule, project.uploadModule)
diff --git a/props-core/build.gradle b/props-core/build.gradle
index b991bd47..534a051b 100644
--- a/props-core/build.gradle
+++ b/props-core/build.gradle
@@ -2,7 +2,7 @@
 archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
-    compile project(":quickcheck")
-    testCompile junitCompile
-    testRuntime junitRuntime
+    api project(":quickcheck")
+    testImplementation junitCompile
+    testRuntimeOnly junitRuntime
 }
diff --git a/props-core/src/test/java/fj/data/ReaderTest.java b/props-core/src/test/java/fj/data/ReaderTest.java
index 4817e41c..48352620 100644
--- a/props-core/src/test/java/fj/data/ReaderTest.java
+++ b/props-core/src/test/java/fj/data/ReaderTest.java
@@ -13,6 +13,7 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertTrue;
 
+
 public class ReaderTest {
 
     @Test
diff --git a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
index 7f02288c..8cc94825 100644
--- a/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
+++ b/props-core/src/test/java/fj/data/fingertrees/FingerTreeTest.java
@@ -8,10 +8,11 @@
 import org.junit.Test;
 
 import static fj.Monoid.intAdditionMonoid;
+import static fj.Monoid.intMinMonoid;
 import static fj.data.fingertrees.FingerTree.measured;
 import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
+import static org.hamcrest.MatcherAssert.assertThat;
 
 public class FingerTreeTest {
 
diff --git a/quickcheck/build.gradle b/quickcheck/build.gradle
index 2e5dbe4c..c9851596 100644
--- a/quickcheck/build.gradle
+++ b/quickcheck/build.gradle
@@ -1,16 +1,15 @@
 
 ext {
     signModule = true
+    uploadModule = true
 }
 
 archivesBaseName = "${project.projectName}-${project.name}"
 
 dependencies {
-	compile project(":core")
-    compile junitCompile
+    api project(":core")
+    api junitCompile
 }
 
 performSigning(signingEnabled, signModule)
-configureUpload(signingEnabled, signModule)
-
-uploadArchives.enabled = true
+configureUpload(signingEnabled, signModule, uploadModule)

From 93c0403576becdffce91fdd9382b831725f6d795 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 17 Feb 2022 23:25:47 +1000
Subject: [PATCH 327/336] Removed deprecated jcenter.  Added mavenLocal before
 mavenCentral in some missing cases.  Fixed deprecated reports html enabled to
 required.

---
 build.gradle | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/build.gradle b/build.gradle
index 9556b473..43e7ae5b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -6,8 +6,8 @@ apply plugin: "com.github.ben-manes.versions"
 buildscript {
     repositories {
         mavenLocal()
-        jcenter()
         mavenCentral()
+        gradlePluginPortal()
     }
 
     dependencies {
@@ -83,9 +83,8 @@ allprojects {
     }
 
     repositories {
-        jcenter()
-        mavenCentral()
         mavenLocal()
+        mavenCentral()
     }
 
 	version = fjVersion
@@ -98,6 +97,7 @@ subprojects {
 
     buildscript {
         repositories {
+            mavenLocal()
             mavenCentral()
         }
     }
@@ -108,7 +108,6 @@ subprojects {
 
 	repositories {
         mavenLocal()
-        jcenter()
 		mavenCentral()
 		maven {
 			url sonatypeRepositoryUrl
@@ -124,8 +123,8 @@ subprojects {
     tasks.withType(Test).configureEach {
         maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1
         if (!generateTestReports) {
-            reports.html.enabled = false
-            reports.junitXml.enabled = false
+            reports.html.required = false
+            reports.junitXml.required = false
         }
     }
 
@@ -141,8 +140,8 @@ task coverage(type: org.gradle.testing.jacoco.tasks.JacocoReport) {
     getSourceDirectories().from(files(subprojects.findAll {subproject -> subproject.name in projectForFoverage} .sourceSets.main.allSource.srcDirs))
 
     reports {
-        html.enabled = true
-        xml.enabled = true
+        html.required = true
+        xml.required = true
     }
 }
 

From 0c7f70139917f46c1f855a7258678e6c1377bf0b Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Thu, 17 Feb 2022 23:39:00 +1000
Subject: [PATCH 328/336] Upgrade from Gradle 7.3 t o7.4

---
 build.gradle                             | 2 +-
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle b/build.gradle
index 43e7ae5b..08204ba9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -16,7 +16,7 @@ buildscript {
     }
 
     wrapper {
-        gradleVersion = "7.3"
+        gradleVersion = "7.4"
         distributionType = Wrapper.DistributionType.ALL
     }
 }
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index fbce071a..b1159fc5 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

From 2ad5cd9f098b574f4e72d4f1924f6c0962621397 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 18 Feb 2022 00:25:11 +1000
Subject: [PATCH 329/336] Do some Travis optimisation

---
 .travis.yml       | 6 +++++-
 gradle.properties | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index bc3fc57f..2fb30bf7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,13 +14,17 @@ matrix:
   allow_failures:
 
 script:
-  - ./gradlew clean test
+  - ./gradlew build --no-daemon
 
 env:
   global:
     - secure: Bun+1FZ29Q3dR9gZ/5brxcSf+zcY5tWrsqOA4GUb5bYCMyORuXQB0FYXuhKR4wB1pFrk1a9EYwRwSu3GwRJVWb+UzF0CNOWF/QG5tGPx32IOXScwlL/KonI4Vhs7Oc0fF4Wdb7euNrT27BU61jbUugjJ642b3n0VBYFYDdquprU=
     - secure: QAxhjqLRa+WHKIzgIJPZ/rM5a5uzqG7E5rsC0YvB25cO712oYXmzsYPia/oSp0chXlYLYMfk2UnLeQCSx2e6ogXRRRa977Q+B33Nt0Hd9SGLtduv6DBrbA2ehLU12Ib4DWe5VhF5eueAunycYcllTvqA5h+pzTtEVbd68ZHncM4=
 
+before_cache:
+  - rm -f  $HOME/.gradle/caches/modules-2/modules-2.lock
+  - rm -fr $HOME/.gradle/caches/*/plugin-resolution/
+
 cache:
   directories:
   - $HOME/.gradle/caches/
diff --git a/gradle.properties b/gradle.properties
index 6ee9a768..e96743fd 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -9,3 +9,4 @@ sonatypePassword = incorrectPwd
 #signing.secretKeyRingFile=
 
 org.gradle.parallel = true
+org.gradle.caching = true

From 1dd3b3e8aa84df1d7788d74bcc17457efbc2511f Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 18 Feb 2022 00:49:23 +1000
Subject: [PATCH 330/336] Update readme for FJ 5.0

---
 README.adoc | 37 +++++++++++--------------------------
 1 file changed, 11 insertions(+), 26 deletions(-)

diff --git a/README.adoc b/README.adoc
index 4ede16b7..e24b3e6f 100644
--- a/README.adoc
+++ b/README.adoc
@@ -8,7 +8,7 @@ image::http://www.functionaljava.org/img/logo-600x144.png[]
 
 Functional Java is an open source library facilitating functional programming in Java. The library implements numerous basic and advanced programming abstractions that assist composition oriented development. Functional Java also serves as a platform for learning functional programming concepts by introducing these concepts using a familiar language.
 
-The library is intended for use in production applications and is thoroughly tested using the technique of automated specification-based testing with ScalaCheck and Functional Java's quickcheck module. Functional Java is compiled with Java 8 targeting Java 7 bytecode. The use of lambdas within the project are back ported with the Retro Lambda library, supporting Java versions 6 to 8.
+The library is intended for use in production applications and is thoroughly tested using the technique of automated specification-based testing with ScalaCheck and Functional Java's quickcheck module.
 
 Functional Java provides abstractions for the following types:
 
@@ -32,16 +32,13 @@ The recommended way to download and use the project is through your build tool.
 
 The Functional Java artifact is published to Maven Central using the group `org.functionaljava` with three published artifacts:
 
-* the core library (`functionaljava` or `functionaljava_1.8` if you use Java 8+)
-* Java 8 specific support (`functionaljava-java8`)
-* property based testing (`functionaljava-quickcheck` or `functionaljava-quickcheck_1.8` if you use Java 8+)
+* the core library (`functionaljava`)
+* property based testing (`functionaljava-quickcheck`)
 
-The latest stable version is `4.9`.  This can be added to your Gradle project by adding the dependencies:
+The latest stable version is `5.0`.  This can be added to your Gradle project by adding the dependencies:
 ----
-compile "org.functionaljava:functionaljava:4.9"
-compile "org.functionaljava:functionaljava-java8:4.9"
-compile "org.functionaljava:functionaljava-quickcheck:4.9"
-compile "org.functionaljava:functionaljava-java-core:4.9"
+compile "org.functionaljava:functionaljava:5.0"
+compile "org.functionaljava:functionaljava-quickcheck:5.0"
 ----
 
 and in Maven:
@@ -49,34 +46,22 @@ and in Maven:
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava</artifactId>
-    <version>4.9</version>
-</dependency>
-<dependency>
-    <groupId>org.functionaljava</groupId>
-    <artifactId>functionaljava-java8</artifactId>
-    <version>4.9</version>
+    <version>5.0</version>
 </dependency>
 <dependency>
     <groupId>org.functionaljava</groupId>
     <artifactId>functionaljava-quickcheck</artifactId>
-    <version>4.9</version>
-</dependency>
-<dependency>
-    <groupId>org.functionaljava</groupId>
-    <artifactId>functionaljava-java-core</artifactId>
-    <version>4.9</version>
+    <version>5.0</version>
 </dependency>
 ----
 
 == Building
 
-FunctionalJava uses the Retro Lambda project to backport Java 8 lambdas to Java 6 bytecode.  This requires access to both JDK 6 and 8.  The build system requires the environment variables `JAVA6_HOME` and `JAVA8_HOME` to refer to the appropriate directories.
-
-Building is done using Gradle 6.8.3.  In the root directory run:
+Building is done using Gradle 7.4.  In the root directory run:
 ----
 ./gradlew
 ----
-This requires access to Java and will download the Gradle build tool and necessary dependencies and build FunctionalJava.
+This requires access to Java 8 and will download the Gradle build tool and necessary dependencies and build FunctionalJava.
 
 == Features
 
@@ -126,4 +111,4 @@ link:etc/LICENCE[The Functional Java license] uses the BSD 3 license (3-clause l
 
 == Release Notes
 
-For release notes for each version, see the directory etc/release-notes.
\ No newline at end of file
+For release notes for each version, see the directory etc/release-notes.

From 1bcfaa1cb1e4a2e1db710984dc3a1ebd374a09c1 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 18 Feb 2022 23:48:22 +1000
Subject: [PATCH 331/336] Updated gradle versions plugin to 0.42.0.  Added arb
 values for ParModule to help with upgrading Scala and Scalacheck

---
 build.gradle                                  |  2 +-
 .../src/main/java/fj/test/Arbitrary.java      | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/build.gradle b/build.gradle
index 08204ba9..c89c9536 100644
--- a/build.gradle
+++ b/build.gradle
@@ -11,7 +11,7 @@ buildscript {
     }
 
     dependencies {
-        classpath "com.github.ben-manes:gradle-versions-plugin:0.36.0"
+        classpath "com.github.ben-manes:gradle-versions-plugin:0.42.0"
         classpath "biz.aQute.bnd:biz.aQute.bnd.gradle:6.1.0"
     }
 
diff --git a/quickcheck/src/main/java/fj/test/Arbitrary.java b/quickcheck/src/main/java/fj/test/Arbitrary.java
index 146d0a9b..04f1e20b 100644
--- a/quickcheck/src/main/java/fj/test/Arbitrary.java
+++ b/quickcheck/src/main/java/fj/test/Arbitrary.java
@@ -23,6 +23,9 @@
 import fj.P6;
 import fj.P7;
 import fj.P8;
+import fj.Unit;
+import fj.control.parallel.ParModule;
+import fj.control.parallel.Strategy;
 import fj.data.*;
 import fj.LcgRng;
 import fj.Ord;
@@ -65,9 +68,12 @@
 import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.concurrent.DelayQueue;
 import java.util.concurrent.Delayed;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.PriorityBlockingQueue;
 import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
 
 /**
  * Common Gen helper functions.
@@ -98,6 +104,24 @@ public static <S, A> Gen<State<S, A>> arbState(Gen<S> as, Cogen<S> cs, Gen<A> aa
         return arbF(cs, arbP2(as, aa)).map(State::unit);
     }
 
+    public static Gen<ParModule> arbParModule() {
+      return Arbitrary.<Unit>arbStrategy().map(s -> ParModule.parModule(s));
+    }
+
+    public static <A> Gen<Strategy<A>> arbStrategy() {
+      Strategy<A> s = Strategy.<A>executorStrategy(fixedThreadsExecutorService(2));
+      return Gen.elements(s);
+    }
+
+    private static ExecutorService fixedThreadsExecutorService(int n) {
+      return Executors.newFixedThreadPool(n, r -> {
+          ThreadFactory tf = Executors.defaultThreadFactory();
+          Thread t = tf.newThread(r);
+          t.setDaemon(true);
+          return t;
+      });
+    }
+
     /**
      * An arbitrary for the LcgRng.
      */

From aad325739af7dae57c921506a66ee8e4f6ddd026 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 18 Feb 2022 23:50:55 +1000
Subject: [PATCH 332/336] Added problematic upgrade tests from
 CheckParModule.scala to CheckParModuleTest.java

---
 .../control/parallel/CheckParModuleTest.java  | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java

diff --git a/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java b/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java
new file mode 100644
index 00000000..dfbbdda5
--- /dev/null
+++ b/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java
@@ -0,0 +1,48 @@
+package fj.control.parallel;
+
+import fj.Equal;
+import fj.F;
+import fj.Monoid;
+import fj.P;
+import fj.P1;
+import fj.P2;
+import fj.data.Stream;
+import fj.test.Arbitrary;
+import fj.test.Property;
+import fj.test.runner.PropertyTestRunner;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static fj.Equal.stringEqual;
+import static fj.Monoid.stringMonoid;
+import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbP1;
+import static fj.test.Arbitrary.arbParModule;
+import static fj.test.Arbitrary.arbStream;
+import static fj.test.Arbitrary.arbString;
+import static fj.test.Property.prop;
+import static fj.test.Property.property;
+
+@RunWith(PropertyTestRunner.class)
+public class CheckParModuleTest {
+
+    public Property parFlatMap() {
+        return property(arbStream(arbString), arbParModule(), (str, pm) -> {
+            F<String, Stream<String>> f = s3 -> Stream.stream(s3, reverse().f(s3));
+            return prop(Equal.streamEqual(stringEqual).eq(str.bind(f), pm.parFlatMap(str, f).claim()));
+        });
+    }
+
+    private F<String, String> reverse() {
+        return s2 -> new StringBuilder(s2).reverse().toString();
+    }
+
+    public Property parFoldMap() {
+        return property(arbStream(arbString), arbParModule(), (str, pm) -> {
+            F<Stream<String>, P2<Stream<String>, Stream<String>>> chunk = x -> P.p(Stream.stream(x.head()), x.tail()._1());
+            return prop(stringEqual.eq(stringMonoid.sumLeft(str.map(reverse())), pm.parFoldMap(str, reverse(), stringMonoid, chunk).claim()));
+        });
+    }
+
+
+}

From 3bced817e36f54c1191f378d9fc9380fb477b567 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Fri, 18 Feb 2022 23:59:51 +1000
Subject: [PATCH 333/336] Removed problematic properties for Scala 2.12 that
 were moved to Java.

---
 .../test/scala/fj/control/parallel/CheckParModule.scala    | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/props-core-scalacheck/src/test/scala/fj/control/parallel/CheckParModule.scala b/props-core-scalacheck/src/test/scala/fj/control/parallel/CheckParModule.scala
index 8e13eb1b..bba1feff 100644
--- a/props-core-scalacheck/src/test/scala/fj/control/parallel/CheckParModule.scala
+++ b/props-core-scalacheck/src/test/scala/fj/control/parallel/CheckParModule.scala
@@ -46,11 +46,4 @@ object CheckParModule extends Properties("ParModule") {
   property("parMapArray") = forAll((s: Array[String], p: ParModule) =>
     arrayEqual(stringEqual).eq(s.map(rev), p.parMap(s, rev).claim)) 
 
-  property("parFlatMap") = forAll((s: Stream[String], p: ParModule) => {
-    val f = (x: String) => Stream.stream(x, rev(x)) : Stream[String]
-    streamEqual(stringEqual).eq(s.bind(f), p.parFlatMap(s, f).claim)})
-
-  property("parFoldMap") = forAll((s: Stream[String], p: ParModule) => {
-    val chunk = (x: Stream[String]) => P.p(Stream.stream(x.head), x.tail._1)
-    stringEqual.eq(stringMonoid.sumLeft(s.map(rev)), p.parFoldMap(s, rev, stringMonoid, chunk).claim)})
 }

From 835ca0fb9ae5278aa3371dfdf73562002747c72c Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 19 Feb 2022 01:02:47 +1000
Subject: [PATCH 334/336] Upgrade to Gradle 2.12. Removed CheckHashMap no null
 values test as the semantics changed with Scala 2.12 so that
 null.asInstanceOf[Int] returns 0 instead of null

---
 core/src/main/java/fj/function/Strings.java          |  4 ++++
 props-core-scalacheck/build.gradle                   | 12 ++++++++++--
 .../src/test/scala/fj/data/CheckArray.scala          |  4 ++--
 .../src/test/scala/fj/data/CheckHashMap.scala        | 11 -----------
 .../java/fj/control/parallel/CheckParModuleTest.java | 12 ++++++------
 5 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/core/src/main/java/fj/function/Strings.java b/core/src/main/java/fj/function/Strings.java
index 1c239e85..d9815248 100644
--- a/core/src/main/java/fj/function/Strings.java
+++ b/core/src/main/java/fj/function/Strings.java
@@ -96,4 +96,8 @@ public static F<List<String>, String> unlines() {
     return Strings::unlines;
   }
 
+  public static F<String, String> reverse() {
+    return s -> new StringBuilder(s).reverse().toString();
+  }
+
 }
diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index 358b365b..faa7d737 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -4,9 +4,17 @@ archivesBaseName = "${project.projectName}-${project.name}"
 apply plugin: 'scala'
 
 ext {
-    scalaVersion = "2.11.12"
-    scalacheckScalaVersion = "2.11"
+//    scalaVersion = "2.11.12"
+//    scalacheckScalaVersion = "2.11"
+    scalaVersion = "2.12.15"
+    scalacheckScalaVersion = "2.12"
+//    scalaVersion = "2.13.8"
+//    scalacheckScalaVersion = "2.13"
+
     scalacheckVersion = "1.12.6"
+//    scalacheckVersion = "1.13.5"
+//    scalacheckVersion = "1.15.2"
+
     signModule = true
 }
 
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckArray.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckArray.scala
index f8cce111..b116a6a9 100755
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckArray.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckArray.scala
@@ -63,7 +63,7 @@ object CheckArray extends Properties("Array") {
       a.reverse.foldRight((a: String, b: Array[String]) => array[String](scala.Array(a): _*).append(b), empty[String])))
 
   property("scans") = forAll((a: Array[Int], z: Int) => {
-    val add = (x: Int, y: Int) => x + y
+    val add: F2[Int, Int, Int] = (x: Int, y: Int) => x + y
     val left = a.scanLeft(add, z)
     val right = a.reverse().scanRight(add, z).reverse()
     
@@ -72,7 +72,7 @@ object CheckArray extends Properties("Array") {
 
   property("scans1") = forAll((a: Array[Int]) =>
     (a.length() > 0) ==> {
-      val add = (x: Int, y: Int) => x + y
+      val add: F2[Int, Int, Int] = (x: Int, y: Int) => x + y
       val left = a.scanLeft1(add)
       val right = a.reverse().scanRight1(add).reverse()
       
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
index dfde81e3..6ebd060d 100755
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
@@ -105,15 +105,4 @@ object CheckHashMap extends Properties("HashMap") {
     keysAreEqual && valuesAreEqual
   })
 
-  property("No null values") = forAll((list: List[Int]) => {
-    val m = HashMap.hashMap[Int, Int]()
-    list.foreachDoEffect(new Effect1[Int] {
-      def f(a: Int) {
-        m.set(a, null.asInstanceOf[Int])
-      }
-    })
-    list.forall(new F[Int, java.lang.Boolean]() {
-      def f(a: Int) = m.contains(a) == false
-    })
-  })
 }
\ No newline at end of file
diff --git a/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java b/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java
index dfbbdda5..0c4f418f 100644
--- a/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java
+++ b/props-core/src/test/java/fj/control/parallel/CheckParModuleTest.java
@@ -7,6 +7,7 @@
 import fj.P1;
 import fj.P2;
 import fj.data.Stream;
+import fj.function.Strings;
 import fj.test.Arbitrary;
 import fj.test.Property;
 import fj.test.runner.PropertyTestRunner;
@@ -28,19 +29,18 @@ public class CheckParModuleTest {
 
     public Property parFlatMap() {
         return property(arbStream(arbString), arbParModule(), (str, pm) -> {
-            F<String, Stream<String>> f = s3 -> Stream.stream(s3, reverse().f(s3));
+            F<String, Stream<String>> f = s3 -> Stream.stream(s3, Strings.reverse().f(s3));
             return prop(Equal.streamEqual(stringEqual).eq(str.bind(f), pm.parFlatMap(str, f).claim()));
         });
     }
 
-    private F<String, String> reverse() {
-        return s2 -> new StringBuilder(s2).reverse().toString();
-    }
-
     public Property parFoldMap() {
         return property(arbStream(arbString), arbParModule(), (str, pm) -> {
             F<Stream<String>, P2<Stream<String>, Stream<String>>> chunk = x -> P.p(Stream.stream(x.head()), x.tail()._1());
-            return prop(stringEqual.eq(stringMonoid.sumLeft(str.map(reverse())), pm.parFoldMap(str, reverse(), stringMonoid, chunk).claim()));
+            return prop(stringEqual.eq(
+                stringMonoid.sumLeft(str.map(Strings.reverse())),
+                pm.parFoldMap(str, Strings.reverse(), stringMonoid, chunk).claim()
+            ));
         });
     }
 

From 4671564744bd18e6d9c77ff03f47d8e3900cf28f Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Sat, 19 Feb 2022 01:22:40 +1000
Subject: [PATCH 335/336] Prep for next Scala version

---
 props-core-scalacheck/build.gradle                              | 1 +
 props-core-scalacheck/src/test/scala/fj/Tests.scala             | 2 +-
 props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala | 2 ++
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/props-core-scalacheck/build.gradle b/props-core-scalacheck/build.gradle
index faa7d737..396d19d4 100644
--- a/props-core-scalacheck/build.gradle
+++ b/props-core-scalacheck/build.gradle
@@ -13,6 +13,7 @@ ext {
 
     scalacheckVersion = "1.12.6"
 //    scalacheckVersion = "1.13.5"
+//    scalacheckVersion = "1.14.0"
 //    scalacheckVersion = "1.15.2"
 
     signModule = true
diff --git a/props-core-scalacheck/src/test/scala/fj/Tests.scala b/props-core-scalacheck/src/test/scala/fj/Tests.scala
index d94661f9..c5ec3977 100644
--- a/props-core-scalacheck/src/test/scala/fj/Tests.scala
+++ b/props-core-scalacheck/src/test/scala/fj/Tests.scala
@@ -18,7 +18,7 @@ object Tests {
     fj.control.parallel.CheckParModule.properties
   ).flatten
 
-  def main(args: Array[String]) {
+  def main(args: Array[String]): scala.Unit = {
     run(tests)
     //    System.exit(0)
   }
diff --git a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
index 6ebd060d..c629a10f 100755
--- a/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
+++ b/props-core-scalacheck/src/test/scala/fj/data/CheckHashMap.scala
@@ -9,6 +9,8 @@ import Hash._
 import Ord._
 import fj.data.Option._
 import scala.collection.JavaConversions._
+//import scala.collection.JavaConverters._
+
 import org.scalacheck.{Arbitrary, Properties}
 import data.ArbitraryList._
 import org.scalacheck.Arbitrary._

From a2f7ebe5ef319df492f547e0be4cc965af667e35 Mon Sep 17 00:00:00 2001
From: Mark Perry <maperry78@yahoo.com.au>
Date: Mon, 7 Mar 2022 18:38:31 +1000
Subject: [PATCH 336/336] Updated doc when releasing FJ 5.0

---
 README.adoc                              | 11 ++++++++--
 etc/release-notes/release-notes-5.1.adoc | 28 ++++++++++++++++++++++++
 etc/release-process.txt                  | 24 ++++++++++++++++----
 3 files changed, 57 insertions(+), 6 deletions(-)
 create mode 100644 etc/release-notes/release-notes-5.1.adoc

diff --git a/README.adoc b/README.adoc
index e24b3e6f..ecf403e2 100644
--- a/README.adoc
+++ b/README.adoc
@@ -34,11 +34,13 @@ The Functional Java artifact is published to Maven Central using the group `org.
 
 * the core library (`functionaljava`)
 * property based testing (`functionaljava-quickcheck`)
+* a small amount of Java 8 support (`functionaljava-java-core`)
 
 The latest stable version is `5.0`.  This can be added to your Gradle project by adding the dependencies:
 ----
 compile "org.functionaljava:functionaljava:5.0"
 compile "org.functionaljava:functionaljava-quickcheck:5.0"
+compile "org.functionaljava:functionaljava-java-core:5.0"
 ----
 
 and in Maven:
@@ -53,11 +55,16 @@ and in Maven:
     <artifactId>functionaljava-quickcheck</artifactId>
     <version>5.0</version>
 </dependency>
+<dependency>
+    <groupId>org.functionaljava</groupId>
+    <artifactId>functionaljava-java-core</artifactId>
+    <version>5.0</version>
+</dependency>
 ----
 
 == Building
 
-Building is done using Gradle 7.4.  In the root directory run:
+Building is done using Java 8 and Gradle 7.4.  In the root directory run:
 ----
 ./gradlew
 ----
@@ -111,4 +118,4 @@ link:etc/LICENCE[The Functional Java license] uses the BSD 3 license (3-clause l
 
 == Release Notes
 
-For release notes for each version, see the directory etc/release-notes.
+For release notes for each version, see the directory link:etc/release-notes.
diff --git a/etc/release-notes/release-notes-5.1.adoc b/etc/release-notes/release-notes-5.1.adoc
new file mode 100644
index 00000000..22dbc552
--- /dev/null
+++ b/etc/release-notes/release-notes-5.1.adoc
@@ -0,0 +1,28 @@
+
+= Release <version>
+
+Proposed release: <quarter> <year>
+
+== Enhancements
+
+* TODO.
+
+== Fixes
+
+* TODO.
+
+== Internal
+
+* TODO.
+
+== Breaking Changes
+
+* TODO.
+
+== Documentation
+
+* TODO.
+
+== Contributors
+
+* TODO.
diff --git a/etc/release-process.txt b/etc/release-process.txt
index e4b35e2d..f5699a5b 100644
--- a/etc/release-process.txt
+++ b/etc/release-process.txt
@@ -1,6 +1,6 @@
 
-Current Release Process
-=======================
+Release Process
+===============
 
 Go through the issues and pull requests and set the Label and Milestone field.  Add information to /etc/release-notes/release-notes-<version>.adoc.
 
@@ -10,7 +10,7 @@ Update gradle.properties:
 
 
 Run the build command:
-gradlew clean build upload
+gradlew clean build publishAllPublicationsToMavenRepository
 
 Login to Sonatype and verify the release:
 * Login to https://oss.sonatype.org
@@ -18,6 +18,7 @@ Login to Sonatype and verify the release:
 * Tick the release and click Close
 * Wait until closed
 * Tick the release and click Release
+* It takes ~24 hours for Sonatype to sync to Maven Central where it should appear
 
 Commit changes
 
@@ -33,12 +34,27 @@ Create tag:
 
 Create the next version of the release notes with empty fields using the template.
 
-Copy the generated javadoc for each component to the website repositories' master branch under /javadoc/<version>.  Commit the javadoc and push.
+Copy the generated javadoc for each component to the website repositories' master branch, see https://github.com/functionaljava/functionaljava.github.io, under /javadoc/<version>.  Copy:
+- core to functionaljava
+- java-core to functionaljava-java-core
+- quickcheck to functionaljava-quickcheck
+
+Commit the javadoc and push.
 
 Update the website and Github README.adoc.  This includes adding any features to the home page and features page.  Updating the doc page with javadoc links.  Update the download page with a link to the latest release notes.
 
 Send a message to the group and social media about the release, TODO.
 
+Setup Sonatype
+======================
+You need to be able to login to https://oss.sonatype.org.  Register or check your login details.
+
+Create/edit the file %UserProfile%\.gradle\gradle.properties, set the values below:
+
+sonatypeUsername = <user>
+sonatypePassword = <pwd>
+
+
 Setup Artifact Signing
 ======================
 The below text is a summary from https://gist.github.com/phit/bd3c6d156a2fa5f3b1bc15fa94b3256c.