TypeSafeEquals.scala

  import language.experimental.macros
  import scala.reflect.macros.Context

  /**
   * Provides type-safe equality and inequality operators, implemented with
   * macros for efficiency reasons.
   */
  implicit class TypeSafeEquals[T](val self: T) extends AnyVal {
    def ===[U](other: U): Boolean = macro TypeSafeEquals.equalsImpl[T, U]

    def ≟[U](other: U): Boolean = macro TypeSafeEquals.equalsImpl[T, U]

    def !==[U](other: U): Boolean = macro TypeSafeEquals.notEqualsImpl[T, U]

    def ≠[U](other: U): Boolean = macro TypeSafeEquals.notEqualsImpl[T, U]
  }
  
  object TypeSafeEquals {
    def equalsImpl[T : c.WeakTypeTag, U : c.WeakTypeTag](c: Context)(other: c.Expr[T]): c.Expr[Boolean] = {
      import c.universe._

      def canProve[A : WeakTypeTag] =
        c.inferImplicitValue(weakTypeOf[A], silent=true) != EmptyTree

      val selfExpr = c.Expr[T](Select(c.prefix.tree, newTermName("self")))
      if (canProve[T <:< U] || canProve[U <:< T])
        reify(selfExpr.splice == other.splice)
      else
        c.abort(c.macroApplication.pos, s"Cannot compare unrelated types ${weakTypeOf[T]} and ${weakTypeOf[U]}")
    }

    def notEqualsImpl[T : c.WeakTypeTag, U : c.WeakTypeTag](c: Context)(other: c.Expr[T]): c.Expr[Boolean] = {
      import c.universe._
      val equality = equalsImpl[T, U](c)(other)
      reify(!equality.splice)
    }
  }