Mapped TSKs can put initial values and the original key can fetch them

jnape · jnape · commit 5c118f11b028 · 2018-05-20T16:21:36.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,9 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Changed
 - `TypeSafeKey.Simple` now has a default `#apply` implementation
 
+### Fixed
+- mapped `TypeSafeKey` instances can be used for initial put in an `HMap`, and the base key can be used to retrieve them
+
 ## [3.0.1] - 2018-05-13
 ### Changed
 - `ToMap` accepts an `Iterable` covariant in `Map.Entry`
diff --git a/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java b/src/main/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKey.java
@@ -6,6 +6,8 @@
 import com.jnape.palatable.lambda.lens.Iso;
 import com.jnape.palatable.lambda.lens.LensLike;
 
+import java.util.Objects;
+
 /**
  * An interface representing a parametrized key for use in {@link HMap}s. Additionally, every {@link TypeSafeKey} is an
  * {@link Iso} from the type the value is stored as to the type it's viewed and set as (on the way in / on the way out).
@@ -87,6 +89,10 @@ public boolean equals(Object obj) {
      */
     static <A> Simple<A> typeSafeKey() {
         return new TypeSafeKey.Simple<A>() {
+            @Override
+            public boolean equals(Object obj) {
+                return obj instanceof Simple ? this == obj : Objects.equals(obj, this);
+            }
         };
     }
 
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/CustomTypeSafeKeyTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/CustomTypeSafeKeyTest.java
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/HMapTest.java
@@ -2,6 +2,7 @@
 
 import org.junit.Test;
 
+import java.math.BigInteger;
 import java.util.HashMap;
 import java.util.NoSuchElementException;
 
@@ -12,6 +13,8 @@
 import static com.jnape.palatable.lambda.adt.hmap.HMap.hMap;
 import static com.jnape.palatable.lambda.adt.hmap.HMap.singletonHMap;
 import static com.jnape.palatable.lambda.adt.hmap.TypeSafeKey.typeSafeKey;
+import static com.jnape.palatable.lambda.lens.Iso.simpleIso;
+import static java.math.BigInteger.ONE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -36,6 +39,28 @@ public void getForAbsentKey() {
                              .get(typeSafeKey()));
     }
 
+    @Test
+    public void storesTypeSafeKeyBaseValue() {
+        TypeSafeKey.Simple<String> stringKey = typeSafeKey();
+        TypeSafeKey<String, Long> longKey = stringKey.andThen(simpleIso(Long::parseLong, String::valueOf));
+        TypeSafeKey<String, BigInteger> bigIntegerKey = longKey.andThen(simpleIso(BigInteger::valueOf, BigInteger::longValue));
+
+        HMap hMap = singletonHMap(stringKey, "1");
+        assertEquals(just("1"), hMap.get(stringKey));
+        assertEquals(just(1L), hMap.get(longKey));
+        assertEquals(just(ONE), hMap.get(bigIntegerKey));
+
+        assertNotEquals(typeSafeKey(), typeSafeKey());
+
+        assertEquals(emptyHMap().put(longKey, 1L).get(longKey), emptyHMap().put(stringKey, "1").get(longKey));
+        assertEquals(emptyHMap().put(stringKey, "1").get(stringKey), emptyHMap().put(longKey, 1L).get(stringKey));
+        assertEquals(emptyHMap().put(stringKey, "1").get(stringKey), emptyHMap().put(bigIntegerKey, ONE).get(stringKey));
+
+        assertEquals(singletonHMap(stringKey, "1"), singletonHMap(longKey, 1L));
+        assertEquals(singletonHMap(stringKey, "1"), singletonHMap(bigIntegerKey, ONE));
+        assertEquals(singletonHMap(longKey, 1L), singletonHMap(bigIntegerKey, ONE));
+    }
+
     @Test
     public void getForPresentKeyWithNullValue() {
         TypeSafeKey<String, String> stringKey = typeSafeKey();
diff --git a/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java b/src/test/java/com/jnape/palatable/lambda/adt/hmap/TypeSafeKeyTest.java
@@ -9,6 +9,7 @@
 import static com.jnape.palatable.lambda.lens.Iso.simpleIso;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static testsupport.assertion.LensAssert.assertLensLawfulness;
 
 
@@ -45,4 +46,29 @@ public void discardRPreservesTypeSafeKey() {
 
         assertEquals(just("123"), map.get(discardedKey));
     }
+
+    @Test
+    public void defaultEquality() {
+        TypeSafeKey.Simple<Object> keyA = typeSafeKey();
+        TypeSafeKey<Object, Object> mappedKeyA = keyA.andThen(simpleIso(id(), id()));
+
+        assertEquals(keyA, keyA);
+        assertEquals(keyA, mappedKeyA);
+        assertEquals(mappedKeyA, keyA);
+        assertEquals(keyA.hashCode(), mappedKeyA.hashCode());
+
+        TypeSafeKey.Simple<Object> keyB = typeSafeKey();
+        assertNotEquals(keyA, keyB);
+        assertNotEquals(keyB, keyA);
+        assertNotEquals(keyB, mappedKeyA);
+        assertNotEquals(mappedKeyA, keyB);
+
+        TypeSafeKey<Object, Object> differentMappedKeyA = keyA.andThen(simpleIso(id(), id()));
+        assertEquals(keyA, differentMappedKeyA);
+        assertEquals(differentMappedKeyA, keyA);
+        assertEquals(mappedKeyA, differentMappedKeyA);
+        assertEquals(differentMappedKeyA, mappedKeyA);
+        assertEquals(keyA.hashCode(), differentMappedKeyA.hashCode());
+        assertEquals(mappedKeyA.hashCode(), differentMappedKeyA.hashCode());
+    }
 }
