Added some useful functions to Equal

l1cache · jbgi · commit 7a30ac732367 · 2018-03-20T14:05:01.000+01:00
diff --git 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
@@ -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));
+  }
+}
