Set up Machinist, use macros for Eq through Order syntax.

This commit adds cats-macros, upon which cats depends.
Right now, the only macros being used are Machinist's
operator macros, which are configured in cats.macros.Ops.

The punchline of doing this is that:

    def xyz[A: Eq](x: A, y: A): Boolean =
      x === y

is now exactly the same as:

    def xyz[A](x: A, y: A)(implicit A: Eq[A]): Boolean =
      A.eqv(x, y)

i.e. the syntax implicit conversions are completely erased.
This eliminates the performance penalty that syntax normally
implies. It also means the syntax classes don't need to be
value classes (or specialized) since they are not used at
runtime.

build.sbt

@@ -56,14 +56,18 @@ lazy val aggregate = project.in(file("."))
   .settings(catsSettings: _*)
   .settings(docSettings: _*)
   .settings(noPublishSettings: _*)
-  .aggregate(core, laws, tests, data, std, examples)
-  .dependsOn(core, laws, tests, data, std, examples)
+  .aggregate(macros, core, laws, tests, data, std, examples)
+  .dependsOn(macros, core, laws, tests, data, std, examples)
 
-lazy val core = project
+lazy val macros = project
+  .settings(moduleName := "cats-macros")
+  .settings(catsSettings: _*)
+
+lazy val core = project.dependsOn(macros)
   .settings(moduleName := "cats")
   .settings(catsSettings: _*)
 
-lazy val laws = project.dependsOn(core, data)
+lazy val laws = project.dependsOn(macros, core, data)
   .settings(moduleName := "cats-laws")
   .settings(catsSettings: _*)
   .settings(
@@ -72,14 +76,14 @@ lazy val laws = project.dependsOn(core, data)
     )
   )
 
-lazy val std = project.dependsOn(core, laws)
+lazy val std = project.dependsOn(macros, core, laws)
   .settings(moduleName := "cats-std")
   .settings(catsSettings: _*)
   .settings(
     libraryDependencies += "org.spire-math" %% "algebra-std" % "0.2.0-SNAPSHOT" from "http://plastic-idolatry.com/jars/algebra-std_2.11-0.2.0-SNAPSHOT.jar"
   )
 
-lazy val tests = project.dependsOn(core, data, std, laws)
+lazy val tests = project.dependsOn(macros, core, data, std, laws)
   .settings(moduleName := "cats-tests")
   .settings(catsSettings: _*)
   .settings(noPublishSettings: _*)
@@ -89,11 +93,11 @@ lazy val tests = project.dependsOn(core, data, std, laws)
     )
   )
 
-lazy val data = project.dependsOn(core)
+lazy val data = project.dependsOn(macros, core)
   .settings(moduleName := "cats-data")
   .settings(catsSettings: _*)
 
-lazy val examples = project.dependsOn(core)
+lazy val examples = project.dependsOn(macros, core)
   .settings(moduleName := "cats-examples")
   .settings(catsSettings: _*)
   .settings(noPublishSettings: _*)

core/src/main/scala/cats/syntax/eq.scala

@@ -1,13 +1,14 @@
 package cats
 package syntax
 
+import cats.macros.Ops
+import scala.language.experimental.macros
+
 trait EqSyntax {
-  // TODO: use simulacrum instances eventually
-  implicit def eqSyntax[A: Eq](a: A) =
-    new EqOps[A](a)
+  implicit def eqSyntax[A: Eq](a: A) = new EqOps[A](a)
 }
 
 class EqOps[A](lhs: A)(implicit A: Eq[A]) {
-  def ===(rhs: A): Boolean = A.eqv(lhs, rhs)
-  def =!=(rhs: A): Boolean = A.neqv(lhs, rhs)
+  def ===(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def =!=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
 }

core/src/main/scala/cats/syntax/order.scala

@@ -1,14 +1,15 @@
 package cats
 package syntax
 
+import cats.macros.Ops
+import scala.language.experimental.macros
+
 trait OrderSyntax {
-  // TODO: use simulacrum instances eventually
-  implicit def orderSyntax[A: Order](a: A) =
-    new OrderOps[A](a)
+  implicit def orderSyntax[A: Order](a: A) = new OrderOps[A](a)
 }
 
 class OrderOps[A](lhs: A)(implicit A: Order[A]) {
-  def compare(rhs: A): Int = A.compare(lhs, rhs)
-  def min(rhs: A): A = A.min(lhs, rhs)
-  def max(rhs: A): A = A.max(lhs, rhs)
+  def compare(rhs: A): Int = macro Ops.binop[A, Int]
+  def min(rhs: A): A = macro Ops.binop[A, A]
+  def max(rhs: A): A = macro Ops.binop[A, A]
 }

core/src/main/scala/cats/syntax/partialOrder.scala

@@ -1,20 +1,21 @@
 package cats
 package syntax
 
+import cats.macros.Ops
+import scala.language.experimental.macros
+
 trait PartialOrderSyntax {
-  // TODO: use simulacrum instances eventually
-  implicit def partialOrderSyntax[A: PartialOrder](a: A) =
-    new PartialOrderOps[A](a)
+  implicit def partialOrderSyntax[A: PartialOrder](a: A) = new PartialOrderOps[A](a)
 }
 
 class PartialOrderOps[A](lhs: A)(implicit A: PartialOrder[A]) {
-  def >(rhs: A): Boolean = A.gt(lhs, rhs)
-  def >=(rhs: A): Boolean = A.gteqv(lhs, rhs)
-  def <(rhs: A): Boolean = A.lt(lhs, rhs)
-  def <=(rhs: A): Boolean = A.lteqv(lhs, rhs)
+  def >(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def >=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def <(rhs: A): Boolean = macro Ops.binop[A, Boolean]
+  def <=(rhs: A): Boolean = macro Ops.binop[A, Boolean]
 
-  def partialCompare(rhs: A): Double = A.partialCompare(lhs, rhs)
-  def tryCompare(rhs: A): Option[Int] = A.tryCompare(lhs, rhs)
-  def pmin(rhs: A): Option[A] = A.pmin(lhs, rhs)
-  def pmax(rhs: A): Option[A] = A.pmax(lhs, rhs)
+  def partialCompare(rhs: A): Double = macro Ops.binop[A, Double]
+  def tryCompare(rhs: A): Option[Int] = macro Ops.binop[A, Option[Int]]
+  def pmin(rhs: A): Option[A] = macro Ops.binop[A, Option[A]]
+  def pmax(rhs: A): Option[A] = macro Ops.binop[A, Option[A]]
 }

macros/src/main/scala/cats/macros/Ops.scala

@@ -0,0 +1,18 @@
+package cats.macros
+
+object Ops extends machinist.Ops {
+
+  def uesc(c: Char): String = "$u%04X".format(c.toInt)
+
+  val operatorNames: Map[String, String] =
+    Map(
+      ("$eq$eq$eq", "eqv"),
+      ("$eq$bang$eq", "neqv"),
+      ("$greater", "gt"),
+      ("$greater$eq", "gteqv"),
+      ("$less", "lt"),
+      ("$less$eq", "lteqv"),
+      ("$bar$plus$bar", "combine"),
+      ("$bar$minus$bar", "remove")
+    )
+}