Do not deprecate monoid/ord/semigroup constructors for non java 8 users.

jbgi · jbgi · commit 05275dbf4196 · 2016-11-06T18:27:54.000+01:00
diff --git a/core/src/main/java/fj/Equal.java b/core/src/main/java/fj/Equal.java
@@ -135,13 +135,28 @@ 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.
    */
   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
@@ -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
@@ -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
@@ -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
@@ -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,23 +53,23 @@ 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();
       } catch (final IOException e) {
         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();
       } catch (final IOException e) {
         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);
