From 770467c1d5313516df29b0a48fd5fa5e4481a877 Mon Sep 17 00:00:00 2001
From: Paul Campbell <pcampbell@kemitix.net>
Date: Sun, 26 Nov 2017 10:04:03 +0000
Subject: [PATCH] TypeAlias requires explicit type class as parameter

TypeAlias makes use of map() and getValue() internally.
---
 src/main/java/net/kemitix/mon/TypeAlias.java  | 25 +++++++++++----
 .../java/net/kemitix/mon/TypeAliasTest.java   | 32 +++++++++++++++++--
 2 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/src/main/java/net/kemitix/mon/TypeAlias.java b/src/main/java/net/kemitix/mon/TypeAlias.java
index 4027e37..0aeda37 100644
--- a/src/main/java/net/kemitix/mon/TypeAlias.java
+++ b/src/main/java/net/kemitix/mon/TypeAlias.java
@@ -38,13 +38,20 @@ public abstract class TypeAlias<T> {
      */
     private final T value;
 
+    private final Class<? super T> type;
+
     /**
      * Constructor.
      *
      * @param value the value
+     * @param type  the type of the value
      */
-    protected TypeAlias(final T value) {
+    protected TypeAlias(
+            final T value,
+            final Class<? super T> type
+                       ) {
         this.value = value;
+        this.type = type;
     }
 
     /**
@@ -56,31 +63,37 @@ public abstract class TypeAlias<T> {
      * @return a TypeAlias
      */
     public final <R> R map(final Function<T, R> f) {
-        return f.apply(value);
+        return f.apply(getValue());
     }
 
     @Override
     public final int hashCode() {
-        return value.hashCode();
+        return getValue().hashCode();
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public final boolean equals(final Object o) {
         if (o instanceof TypeAlias) {
-            return value.equals(((TypeAlias) o).value);
+            if (((TypeAlias) o).type.equals(type)) {
+                return ((TypeAlias<T>) o).map(getValue()::equals);
+            } else {
+                return false;
+            }
         }
-        return value.equals(o);
+        return map(o::equals);
     }
 
     @Override
     public final String toString() {
-        return value.toString();
+        return getValue().toString();
     }
 
     /**
      * Get the value of the type alias.
      *
      * @return the value
+     *
      * @deprecated try using {@link #map(Function)}
      */
     @Deprecated
diff --git a/src/test/java/net/kemitix/mon/TypeAliasTest.java b/src/test/java/net/kemitix/mon/TypeAliasTest.java
index 3e04110..41c4222 100644
--- a/src/test/java/net/kemitix/mon/TypeAliasTest.java
+++ b/src/test/java/net/kemitix/mon/TypeAliasTest.java
@@ -2,6 +2,7 @@ package net.kemitix.mon;
 
 import org.junit.Test;
 
+import java.util.Collections;
 import java.util.function.Function;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -13,12 +14,28 @@ public class TypeAliasTest {
         //given
         final String value = "value";
         //when
-        final TypeAlias<String> typeAlias = new TypeAlias<String>(value) {
-        };
+        final TypeAlias<String> typeAlias = givenTypeAlias(value);
         //then
         assertThat(typeAlias.<Boolean>map(value::equals)).isTrue();
     }
 
+    @Test
+    public void shouldCreateATypeAliasWithNestedGenericTypes() {
+        //given
+        final Iterable<String> iterable = Collections.emptyList();
+        //when
+        final TypeAlias<Iterable<String>> typeAlias =
+                new TypeAlias<Iterable<String>>(iterable, Iterable.class) {
+        };
+        //then
+        assertThat(typeAlias.<Boolean>map(iterable::equals)).isTrue();
+    }
+
+    private TypeAlias<String> givenTypeAlias(final String value) {
+        return new TypeAlias<String>(value, String.class) {
+        };
+    }
+
     @Test
     public void shouldCreateAnAliasedTypeAndGetTheValue() throws Exception {
         //given
@@ -29,6 +46,15 @@ public class TypeAliasTest {
         assertThat(anAlias.<Boolean>map(value::equals)).isTrue();
     }
 
+    @Test
+    public void shouldNotBeEqualWhenValueTypesAreDifferent() {
+        //given
+        final TypeAlias<String> stringTypeAlias = givenTypeAlias("1");
+        final TypeAlias<Integer> integerTypeAlias = new TypeAlias<Integer>(1, Integer.class){};
+        //then
+        assertThat(stringTypeAlias).isNotEqualTo(integerTypeAlias);
+    }
+
     @Test
     public void shouldBeEqualWhenValuesAreTheSame() throws Exception {
         //given
@@ -86,7 +112,7 @@ public class TypeAliasTest {
          * @param value the value
          */
         protected AnAlias(final String value) {
-            super(value);
+            super(value, String.class);
         }
 
         protected static AnAlias of(final String value) {