use implicit mappers for typed Id conversion

2 files changed, 11 insertions, 26 deletions

diff --git a/src/main/scala/xyz/driver/core/core.scala b/src/main/scala/xyz/driver/core/core.scala
index d1128b6..783150a 100644
--- a/src/main/scala/xyz/driver/core/core.scala
+++ b/src/main/scala/xyz/driver/core/core.scala
@@ -1,7 +1,6 @@
 package xyz.driver
 
 import scalaz.Equal
-import scala.annotation.implicitNotFound
 
 package object core {
 
@@ -34,25 +33,8 @@ package core {
     implicit def idEqual[T]: Equal[Id[T]]       = Equal.equal[Id[T]](_ == _)
     implicit def idOrdering[T]: Ordering[Id[T]] = Ordering.by[Id[T], String](_.value)
 
-    /**
-      * Evidence that Id[A] can be safely converted to Id[B].
-      * e.g. `implicit val CaseId = Id.SameId[Case, CasesRow]`
-      * if `CaseId` is in scope, we can use either of:
-      * `casesRowId.asId[Case]` or `caseId.asId[CasesRow]`
-      *  Override convert for custom Id conversions.
-      */
-    @implicitNotFound("No evidence that ${A} has the same Id as ${B}")
-    sealed trait SameId[A, B] {
-      def convert(id: Id[A]): Id[B] = Id[B](id.value)
-    }
-
-    object SameId {
-      def apply[A, B] = new SameId[A, B] {}
-      implicit def symmetric[A, B](implicit ab: SameId[A, B]): SameId[B, A] = SameId[B, A]
-    }
-
-    implicit class InvariantIdOps[Tag](id: Id[Tag]) {
-      def asId[T](implicit eq: SameId[Tag, T]): Id[T] = eq.convert(id)
+    object Mapper {
+      def apply[A, B]: (Id[A] => Id[B]) = (id: Id[A]) => Id[B](id.value)
     }
   }
 
diff --git a/src/test/scala/xyz/driver/core/CoreTest.scala b/src/test/scala/xyz/driver/core/CoreTest.scala
index 1ccd707..72b6bc6 100644
--- a/src/test/scala/xyz/driver/core/CoreTest.scala
+++ b/src/test/scala/xyz/driver/core/CoreTest.scala
@@ -44,14 +44,17 @@ class CoreTest extends FlatSpec with Matchers with MockitoSugar {
     final case class Y(id: Id[Y])
     final case class Z(id: Id[Z])
 
-    implicit val xy = Id.SameId[X,Y]
-    implicit val yz = Id.SameId[Y,Z]
+    implicit val xy = Id.Mapper[X,Y]
+    implicit val yx = Id.Mapper[Y,X]
+    implicit val yz = Id.Mapper[Y,Z]
+    implicit val zy = Id.Mapper[Z,Y]
 
     val x = X(Id("0"))
-    val y = Y(x.id.asId[Y])
-    val z = Z(y.id.asId[Z])
-    val y2 = Y(z.id.asId[Y])
-    val x2 = X(z.id.asId[Y].asId[X])
+    val y = Y(x.id)
+    val z = Z(y.id)
+    val y2 = Y(z.id)
+    val x2 = X(y2.id)
+
     x2 === x
     y2 === y
   }