Product2 implements Map.Entry, Into takes Map.Entry

jnape · jnape · commit e84c8e3ade88 · 2018-06-16T18:57:20.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -15,7 +15,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Changed
 - `Tuple2-8` now implement `Product2-8`
-- `Into2-8` now accept a product of the same cardinality, instead of requiring a tuple
+- `Into` now accepts `Map.Entry`
+- `Into3-8` now accept a product of the same cardinality, instead of requiring a tuple
 - `CoProduct2-8#project` now return generalized products
 - `Choice2-8#project` return tuples
 
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/product/Product2.java b/src/main/java/com/jnape/palatable/lambda/adt/product/Product2.java
@@ -2,6 +2,7 @@
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
 
+import java.util.Map;
 import java.util.function.BiFunction;
 
 /**
@@ -14,7 +15,7 @@
  * @param <_2> The second element type
  * @see Tuple2
  */
-public interface Product2<_1, _2> {
+public interface Product2<_1, _2> extends Map.Entry<_1, _2> {
 
     /**
      * Retrieve the first element.
@@ -41,4 +42,19 @@ public interface Product2<_1, _2> {
     default <R> R into(BiFunction<? super _1, ? super _2, ? extends R> fn) {
         return fn.apply(_1(), _2());
     }
+
+    @Override
+    default _1 getKey() {
+        return _1();
+    }
+
+    @Override
+    default _2 getValue() {
+        return _2();
+    }
+
+    @Override
+    default _2 setValue(_2 value) {
+        throw new UnsupportedOperationException();
+    }
 }
diff --git a/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into.java b/src/main/java/com/jnape/palatable/lambda/functions/builtin/fn2/Into.java
@@ -1,43 +1,43 @@
 package com.jnape.palatable.lambda.functions.builtin.fn2;
 
-import com.jnape.palatable.lambda.adt.product.Product2;
 import com.jnape.palatable.lambda.functions.Fn1;
 import com.jnape.palatable.lambda.functions.Fn2;
 
+import java.util.Map;
 import java.util.function.BiFunction;
 
 /**
- * Given a <code>{@link BiFunction}&lt;A, B, C&gt;</code> and a <code>{@link Product2}&lt;A, B&gt;</code>, destructure
- * the product and apply the slots as arguments to the function, returning the result.
+ * Given a <code>{@link BiFunction}&lt;A, B, C&gt;</code> and a <code>{@link Map.Entry}&lt;A, B&gt;</code>, destructure
+ * the entry and apply the key and value as arguments to the function, returning the result.
  *
  * @param <A> the first argument type
  * @param <B> the second argument type
  * @param <C> the result type
  */
-public final class Into<A, B, C> implements Fn2<BiFunction<? super A, ? super B, ? extends C>, Product2<A, B>, C> {
+public final class Into<A, B, C> implements Fn2<BiFunction<? super A, ? super B, ? extends C>, Map.Entry<A, B>, C> {
 
     private static final Into INSTANCE = new Into();
 
     private Into() {
     }
 
     @Override
-    public C apply(BiFunction<? super A, ? super B, ? extends C> fn, Product2<A, B> product) {
-        return product.into(fn);
+    public C apply(BiFunction<? super A, ? super B, ? extends C> fn, Map.Entry<A, B> entry) {
+        return fn.apply(entry.getKey(), entry.getValue());
     }
 
     @SuppressWarnings("unchecked")
     public static <A, B, C> Into<A, B, C> into() {
         return INSTANCE;
     }
 
-    public static <A, B, C> Fn1<Product2<A, B>, C> into(
+    public static <A, B, C> Fn1<Map.Entry<A, B>, C> into(
             BiFunction<? super A, ? super B, ? extends C> fn) {
         return Into.<A, B, C>into().apply(fn);
     }
 
     public static <A, B, C> C into(BiFunction<? super A, ? super B, ? extends C> fn,
-                                   Product2<A, B> product) {
-        return Into.<A, B, C>into(fn).apply(product);
+                                   Map.Entry<A, B> entry) {
+        return Into.<A, B, C>into(fn).apply(entry);
     }
 }
diff --git a/src/test/java/com/jnape/palatable/lambda/functions/recursion/TrampolineTest.java b/src/test/java/com/jnape/palatable/lambda/functions/recursion/TrampolineTest.java
@@ -1,10 +1,10 @@
 package com.jnape.palatable.lambda.functions.recursion;
 
 import com.jnape.palatable.lambda.adt.hlist.Tuple2;
-import com.jnape.palatable.lambda.adt.product.Product2;
 import org.junit.Test;
 
 import java.math.BigInteger;
+import java.util.Map;
 import java.util.function.Function;
 
 import static com.jnape.palatable.lambda.adt.hlist.HList.tuple;
@@ -17,7 +17,7 @@
 
 public class TrampolineTest {
 
-    private static final Function<Product2<BigInteger, BigInteger>, RecursiveResult<Tuple2<BigInteger, BigInteger>, BigInteger>> FACTORIAL =
+    private static final Function<Map.Entry<BigInteger, BigInteger>, RecursiveResult<Tuple2<BigInteger, BigInteger>, BigInteger>> FACTORIAL =
             into((x, acc) -> x.compareTo(ONE) > 0 ? recurse(tuple(x.subtract(ONE), x.multiply(acc))) : terminate(acc));
 
     @Test
