Move fluent Equal/Ord construction api to the Definition interfaces.

jbgi · jbgi · commit c4f1f6830a7f · 2018-03-20T14:05:09.000+01:00
Also remove Equal.or and Equal.and as there is no precise use case.
diff --git 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
@@ -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
@@ -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
@@ -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));
