From 2b4ef02a92e431b16d9b314def1da204fd1f9ab1 Mon Sep 17 00:00:00 2001
From: Piotr Krzemiński <pio.krzeminski@gmail.com>
Date: Wed, 21 Jun 2017 13:17:43 +0100
Subject: initial support for 2-arg contravariant derivations; works for simple
 Eq typeclass, still wip

---
 examples/src/main/scala/example.scala | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

(limited to 'examples')

diff --git a/examples/src/main/scala/example.scala b/examples/src/main/scala/example.scala
index e649b88..c649fba 100644
--- a/examples/src/main/scala/example.scala
+++ b/examples/src/main/scala/example.scala
@@ -14,13 +14,23 @@ object `package` {
   implicit val showBool: Show[Boolean] = _.toString
   implicit def showList[T: Show]: Show[List[T]] = xs => xs.map { x => s"list:${implicitly[Show[T]].show(x)}" }.mkString(";")
   implicit def showSet[T: Show]: Show[Set[T]] = s => "set"
+
+  implicit class Equable[T: Eq](t: T) {
+    def isEqualTo(other: T): Boolean = implicitly[Eq[T]].isEqual(t, other)
+  }
+  implicit val eqString: Eq[String] = _ == _
+  implicit val eqBool: Eq[Boolean] = _ == _
+  implicit def eqList[T: Eq]: Eq[List[T]] =
+    (l1, l2) => l1.size == l2.size && (l1 zip l2).forall { case (e1, e2) => e1 isEqualTo e2 }
+  implicit def eqSet[T: Eq]: Eq[Set[T]] =
+    (s1, s2) => s1.size == s2.size && (s1 zip s2).forall { case (e1, e2) => e1 isEqualTo e2 }
 }
 
 sealed trait EmptyType
 
 sealed trait Tree
 case class Branch(left: Tree, right: Tree) extends Tree
-case class Leaf(value: Int, no: EmptyType) extends Tree
+case class Leaf(value: Int, no: String) extends Tree
 
 sealed trait Entity
 case class Person(name: String, address: Address) extends Entity
@@ -42,3 +52,23 @@ object Show extends Show_1 {
 trait Show_1 {
   implicit def generic[T]: Show[T] = macro Macros.magnolia[T, Show[_]]
 }
+
+trait Eq[T] { def isEqual(a: T, b: T): Boolean }
+
+object Eq extends Eq_1 {
+
+  implicit val eqInt: Eq[Int] = _ == _
+
+  implicit val derivation = new ContravariantDerivation2[Eq] {
+    type Return = Boolean
+    def call[T](eq: Eq[T], value1: T, value2: T): Boolean =
+      if(value1.getClass == value2.getClass) eq.isEqual(value1, value2) else false
+    def construct[T](body: (T, T) => Boolean): Eq[T] = body(_, _)
+    def join(elements: ListMap[String, Boolean]): Boolean = elements.forall(_._2)
+  }
+}
+
+trait Eq_1 {
+  implicit def generic[T]: Eq[T] = macro Macros.magnolia[T, Eq[_]]
+}
+
-- 
cgit v1.2.3