adding BiPredicate

jnape · jnape · commit d62119da9d5b · 2016-11-16T22:30:47.000-06:00
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/specialized/BiPredicate.java b/src/main/java/com/jnape/palatable/lambda/functions/specialized/BiPredicate.java
@@ -0,0 +1,82 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import com.jnape.palatable.lambda.adt.hlist.Tuple2;
+import com.jnape.palatable.lambda.functions.Fn2;
+
+/**
+ * A specialized {@link Fn2} that returns a Boolean when fully applied,
+ * or a {@link Predicate} when partially applied.
+ *
+ * @param <A> the first argument type
+ * @param <B> the second argument type
+ */
+@FunctionalInterface
+public interface BiPredicate<A, B> extends Fn2<A, B, Boolean>, java.util.function.BiPredicate<A, B> {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default boolean test(A a, B b) {
+        return apply(a, b);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default Predicate<B> apply(A a) {
+        return Fn2.super.apply(a)::apply;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default BiPredicate<B, A> flip() {
+        return (BiPredicate<B, A>) Fn2.super.flip();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    default Predicate<Tuple2<A, B>> uncurry() {
+        return Fn2.super.uncurry()::apply;
+    }
+
+    /**
+     * Override of {@link java.util.function.BiPredicate#and(java.util.function.BiPredicate)}, returning an instance of
+     * <code>BiPredicate</code> for compatibility. Left-to-right composition.
+     *
+     * @param other the biPredicate to test if this one succeeds
+     * @return a biPredicate representing the conjunction of this biPredicate and other
+     */
+    @Override
+    default BiPredicate<A, B> and(java.util.function.BiPredicate<? super A, ? super B> other) {
+        return (a, b) -> apply(a, b) && other.test(a, b);
+    }
+
+    /**
+     * Override of {@link java.util.function.BiPredicate#or(java.util.function.BiPredicate)}, returning an instance of
+     * <code>BiPredicate</code> for compatibility. Left-to-right composition.
+     *
+     * @param other the biPredicate to test if this one fails
+     * @return a biPredicate representing the disjunction of this biPredicate and other
+     */
+    @Override
+    default BiPredicate<A, B> or(java.util.function.BiPredicate<? super A, ? super B> other) {
+        return (a, b) -> apply(a, b) || other.test(a, b);
+    }
+
+    /**
+     * Override of {@link java.util.function.BiPredicate#negate()}, returning an instance of <code>BiPredicate</code>
+     * for compatibility.
+     *
+     * @return the negation of this biPredicate
+     */
+    @Override
+    default BiPredicate<A, B> negate() {
+        return (a, b) -> !apply(a, b);
+    }
+}
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/specialized/BiPredicateTest.java b/src/test/java/com/jnape/palatable/lambda/functions/specialized/BiPredicateTest.java
@@ -0,0 +1,53 @@
+package com.jnape.palatable.lambda.functions.specialized;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class BiPredicateTest {
+
+    @Test
+    public void jufBiPredicateTest() {
+        BiPredicate<String, String> equals = String::equals;
+
+        assertTrue(equals.test("abc", "abc"));
+        assertFalse(equals.test("abc", ""));
+        assertFalse(equals.test("", "abc"));
+    }
+
+    @Test
+    public void jufBiPredicateAnd() {
+        BiPredicate<Integer, Integer> bothOdd = (x, y) -> x % 2 == 1 && y % 2 == 1;
+        BiPredicate<Integer, Integer> greaterThan = (x, y) -> x.compareTo(y) > 0;
+
+        BiPredicate<Integer, Integer> conjunction = bothOdd.and(greaterThan);
+
+        assertTrue(conjunction.test(3, 1));
+        assertFalse(conjunction.test(3, 2));
+        assertFalse(conjunction.test(3, 5));
+        assertFalse(conjunction.test(4, 1));
+    }
+
+    @Test
+    public void jufBiPredicateOr() {
+        BiPredicate<Integer, Integer> bothOdd = (x, y) -> x % 2 == 1 && y % 2 == 1;
+        BiPredicate<Integer, Integer> greaterThan = (x, y) -> x.compareTo(y) > 0;
+
+        BiPredicate<Integer, Integer> disjunction = bothOdd.or(greaterThan);
+
+        assertTrue(disjunction.test(3, 2));
+        assertTrue(disjunction.test(1, 3));
+        assertFalse(disjunction.test(1, 2));
+    }
+
+    @Test
+    public void jufBiPredicateNegate() {
+        BiPredicate<String, String> equals = String::equals;
+
+        assertTrue(equals.test("a", "a"));
+        assertFalse(equals.test("b", "a"));
+        assertFalse(equals.negate().test("a", "a"));
+        assertTrue(equals.negate().test("b", "a"));
+    }
+}
