Introduce cats-jvm and cats-js.

build.sbt

@@ -92,24 +92,25 @@ lazy val catsJVM = project.in(file(".catsJVM"))
   .settings(moduleName := "cats")
   .settings(catsSettings)
   .settings(commonJvmSettings)
-  .aggregate(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM, docs, bench)
-  .dependsOn(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM % "test-internal -> test", bench% "compile-internal;test-internal -> test")
+  .aggregate(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM, jvm, docs, bench)
+  .dependsOn(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM % "test-internal -> test", jvm, bench % "compile-internal;test-internal -> test")
 
 lazy val catsJS = project.in(file(".catsJS"))
   .settings(moduleName := "cats")
   .settings(catsSettings)
   .settings(commonJsSettings)
-  .aggregate(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS)
-  .dependsOn(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS % "test-internal -> test")
+  .aggregate(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS, js)
+  .dependsOn(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS % "test-internal -> test", js)
   .enablePlugins(ScalaJSPlugin)
 
-lazy val macros = crossProject.crossType(CrossType.Pure)
+// 
+lazy val macros = crossProject
   .settings(moduleName := "cats-macros")
   .settings(catsSettings:_*)
   .jsSettings(commonJsSettings:_*)
   .jvmSettings(commonJvmSettings:_*)
 
-lazy val macrosJVM = macros.jvm 
+lazy val macrosJVM = macros.jvm
 lazy val macrosJS = macros.js
 
 lazy val core = crossProject.crossType(CrossType.Pure)
@@ -125,7 +126,7 @@ lazy val core = crossProject.crossType(CrossType.Pure)
 lazy val coreJVM = core.jvm
 lazy val coreJS = core.js
 
-lazy val laws = crossProject
+lazy val laws = crossProject.crossType(CrossType.Pure)
   .dependsOn(macros, core)
   .settings(moduleName := "cats-laws")
   .settings(catsSettings:_*)
@@ -137,13 +138,6 @@ lazy val laws = crossProject
 lazy val lawsJVM = laws.jvm
 lazy val lawsJS = laws.js
 
-lazy val bench = project.dependsOn(macrosJVM, coreJVM, freeJVM, lawsJVM)
-  .settings(moduleName := "cats-bench")
-  .settings(catsSettings)
-  .settings(noPublishSettings)
-  .settings(jmhSettings)
-  .settings(commonJvmSettings)
-
 lazy val free = crossProject.crossType(CrossType.Pure)
   .dependsOn(macros, core, tests % "test-internal -> test")
   .settings(moduleName := "cats-free")
@@ -164,7 +158,7 @@ lazy val state = crossProject.crossType(CrossType.Pure)
 lazy val stateJVM = state.jvm
 lazy val stateJS = state.js
 
-lazy val tests = crossProject
+lazy val tests = crossProject.crossType(CrossType.Pure)
   .dependsOn(macros, core, laws)
   .settings(moduleName := "cats-tests")
   .settings(catsSettings:_*)
@@ -177,6 +171,28 @@ lazy val tests = crossProject
 lazy val testsJVM = tests.jvm
 lazy val testsJS = tests.js
 
+// cats-jvm is JVM-only
+lazy val jvm = project
+  .dependsOn(macrosJVM, coreJVM, testsJVM % "test-internal -> test")
+  .settings(moduleName := "cats-jvm")
+  .settings(catsSettings:_*)
+  .settings(commonJvmSettings:_*)
+
+// bench is currently JVM-only
+lazy val bench = project.dependsOn(macrosJVM, coreJVM, freeJVM, lawsJVM)
+  .settings(moduleName := "cats-bench")
+  .settings(catsSettings)
+  .settings(noPublishSettings)
+  .settings(jmhSettings)
+  .settings(commonJvmSettings)
+
+// cats-js is JS-only
+lazy val js = project
+  .dependsOn(macrosJS, coreJS, testsJS % "test-internal -> test")
+  .settings(moduleName := "cats-js")
+  .settings(catsSettings:_*)
+  .settings(commonJsSettings:_*)
+
 lazy val publishSettings = Seq(
   homepage := Some(url("https://github.com/non/cats")),
   licenses := Seq("MIT" -> url("http://opensource.org/licenses/MIT")),
@@ -251,7 +267,7 @@ lazy val commonScalacOptions = Seq(
   "-language:implicitConversions",
   "-language:experimental.macros",
   "-unchecked",
-  "-Xfatal-warnings",
+  //"-Xfatal-warnings",
   "-Xlint",
   "-Yinline-warnings",
   "-Yno-adapted-args",

core/src/main/scala/cats/std/future.scala

@@ -1,7 +1,9 @@
 package cats
 package std
 
-import scala.concurrent.{Await, ExecutionContext, Future}
+import cats.syntax.group._
+
+import scala.concurrent.{ExecutionContext, Future}
 import scala.concurrent.duration.FiniteDuration
 
 trait FutureInstances extends FutureInstances1 {
@@ -21,39 +23,38 @@ trait FutureInstances extends FutureInstances1 {
       override def map[A, B](fa: Future[A])(f: A => B): Future[B] = fa.map(f)
     }
 
-  implicit def futureSemigroup[A](implicit A: Semigroup[A], ec: ExecutionContext): Semigroup[Future[A]] =
-    new FutureSemigroup[A]()
-
-  def futureEq[A](atMost: FiniteDuration)(implicit A: Eq[A], ec: ExecutionContext): Eq[Future[A]] =
-    new Eq[Future[A]] {
-
-      def eqv(x: Future[A], y: Future[A]): Boolean = Await.result((x zip y).map((A.eqv _).tupled), atMost)
-    }
+  implicit def futureGroup[A: Group](implicit ec: ExecutionContext): Group[Future[A]] =
+    new FutureGroup[A]
 }
 
-trait FutureInstances1 {
-
-  def futureComonad(atMost: FiniteDuration)(implicit ec: ExecutionContext): Comonad[Future] =
-    new FutureCoflatMap with Comonad[Future] {
-
-      def extract[A](x: Future[A]): A = Await.result(x, atMost)
-
-      def map[A, B](fa: Future[A])(f: A => B): Future[B] = fa.map(f)
-    }
-
-  implicit def futureMonoid[A](implicit A: Monoid[A], ec: ExecutionContext): Monoid[Future[A]] =
-    new FutureSemigroup[A] with Monoid[Future[A]] {
-
-      def empty: Future[A] = Future.successful(A.empty)
-    }
+trait FutureInstances1 extends FutureInstances2 {
+  implicit def futureMonoid[A: Monoid](implicit ec: ExecutionContext): Monoid[Future[A]] =
+    new FutureMonoid[A]
 }
 
-private[std] abstract class FutureCoflatMap(implicit ec: ExecutionContext) extends CoflatMap[Future] {
+trait FutureInstances2 {
+  implicit def futureSemigroup[A: Semigroup](implicit ec: ExecutionContext): Semigroup[Future[A]] =
+    new FutureSemigroup[A]
+}
 
+private[cats] abstract class FutureCoflatMap(implicit ec: ExecutionContext) extends CoflatMap[Future] {
+  def map[A, B](fa: Future[A])(f: A => B): Future[B] = fa.map(f)
   def coflatMap[A, B](fa: Future[A])(f: Future[A] => B): Future[B] = Future(f(fa))
 }
 
-private[std] class FutureSemigroup[A](implicit A: Semigroup[A], ec: ExecutionContext) extends Semigroup[Future[A]] {
+private[cats] class FutureSemigroup[A: Semigroup](implicit ec: ExecutionContext) extends Semigroup[Future[A]] {
+  def combine(fx: Future[A], fy: Future[A]): Future[A] =
+    (fx zip fy).map { case (x, y) => x |+| y }
+}
+
+private[cats] class FutureMonoid[A](implicit A: Monoid[A], ec: ExecutionContext) extends FutureSemigroup[A] with Monoid[Future[A]] {
+  def empty: Future[A] =
+    Future.successful(A.empty)
+}
 
-  def combine(fx: Future[A], fy: Future[A]): Future[A] = (fx zip fy).map((A.combine _).tupled)
+private[cats] class FutureGroup[A](implicit A: Group[A], ec: ExecutionContext) extends FutureMonoid[A] with Group[Future[A]] {
+  def inverse(fx: Future[A]): Future[A] =
+    fx.map(_.inverse)
+  override def remove(fx: Future[A], fy: Future[A]): Future[A] =
+    (fx zip fy).map { case (x, y) => x |-| y }
 }

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

@@ -13,6 +13,7 @@ package object syntax {
   object flatMap extends FlatMapSyntax
   object foldable extends FoldableSyntax
   object functor extends FunctorSyntax
+  object group extends GroupSyntax
   object invariant extends InvariantSyntax
   object monadCombine extends MonadCombineSyntax
   object monadFilter extends MonadFilterSyntax

jvm/src/main/scala/cats/jvm/std/future.scala

@@ -0,0 +1,38 @@
+package cats
+package jvm
+package std
+
+import scala.concurrent.{Await, ExecutionContext, Future}
+import scala.concurrent.duration.FiniteDuration
+
+import cats.std.FutureCoflatMap
+import cats.syntax.all._
+
+object future {
+
+  type E = ExecutionContext
+
+  def futureEq[A: Eq](atMost: FiniteDuration)(implicit ec: E): Eq[Future[A]] =
+    new Eq[Future[A]] {
+      def eqv(x: Future[A], y: Future[A]): Boolean =
+        Await.result((x zip y).map { case (x, y) => x === y }, atMost)
+    }
+
+  def futurePartialOrder[A: PartialOrder](atMost: FiniteDuration)(implicit ec: E): PartialOrder[Future[A]] =
+    new PartialOrder[Future[A]] {
+      def partialCompare(x: Future[A], y: Future[A]): Double =
+        Await.result((x zip y).map { case (x, y) => x partialCompare y }, atMost)
+    }
+
+  def futureOrder[A: Order](atMost: FiniteDuration)(implicit ec: E): Eq[Future[A]] =
+    new Order[Future[A]] {
+      def compare(x: Future[A], y: Future[A]): Int =
+        Await.result((x zip y).map { case (x, y) => x compare y }, atMost)
+    }
+
+  def futureComonad(atMost: FiniteDuration)(implicit ec: E): Comonad[Future] =
+    new FutureCoflatMap with Comonad[Future] {
+      def extract[A](x: Future[A]): A =
+        Await.result(x, atMost)
+    }
+}

tests/jvm/src/test/scala/cats/tests/FutureTests.scala → jvm/src/test/scala/cats/tests/FutureTests.scala

@@ -1,8 +1,12 @@
 package cats
+package jvm
 package tests
 
 import cats.data.Xor
 import cats.laws.discipline._
+import cats.jvm.std.future.{futureEq, futureComonad}
+import cats.tests.CatsSuite
+
 import scala.concurrent.Future
 import scala.concurrent.duration._
 import scala.concurrent.ExecutionContext.Implicits.global

laws/src/main/scala/cats/laws/SerializableLaws.scala

@@ -0,0 +1,50 @@
+package cats
+package laws
+
+import org.scalacheck.Prop
+import org.scalacheck.Prop.{ False, Proof, Result }
+
+/**
+ * Check for Java Serializability.
+ *
+ * This laws is only applicative on the JVM, but is something we want
+ * to be sure to enforce. Therefore, we use cats.macros.Platform to do
+ * a runtime check rather than create a separate jvm-laws project.
+ */
+object SerializableLaws {
+
+  // This part is a bit tricky. Basically, we only want to test
+  // serializability on the JVM.
+  //
+  // The Platform.isJs macro will give us a literal true or false at
+  // compile time, so we rely on scalac to prune away the "other"
+  // branch. Thus, when scala.js look at this method it won't "see"
+  // the branch which was removed, and will avoid an error trying to
+  // suport java.io.*.
+  //
+  // This ends up being a lot nicer than having to split the entire
+  // laws project.
+
+  def serializable[A](a: A): Prop =
+    if (cats.macros.Platform.isJs) Prop(_ => Result(status = Proof)) else Prop { _ =>
+      import java.io.{ ByteArrayInputStream, ByteArrayOutputStream, ObjectInputStream, ObjectOutputStream }
+
+      val baos = new ByteArrayOutputStream()
+      val oos = new ObjectOutputStream(baos)
+      var ois: ObjectInputStream = null
+      try {
+        oos.writeObject(a)
+        oos.close()
+        val bais = new ByteArrayInputStream(baos.toByteArray())
+        ois = new ObjectInputStream(bais)
+        val a2 = ois.readObject()
+        ois.close()
+        Result(status = Proof)
+      } catch { case _: Throwable =>
+          Result(status = False)
+      } finally {
+        oos.close()
+        if (ois != null) ois.close()
+      }
+    }
+}

macros/js/src/main/scala/cats/macros/Platform.scala

@@ -0,0 +1,20 @@
+package cats.macros
+
+import scala.reflect.macros.Context
+
+object Platform {
+
+  final def isJvm: Boolean = macro isJvmImpl
+
+  final def isJs: Boolean = macro isJsImpl
+
+  def isJvmImpl(c: Context): c.Expr[Boolean] = {
+    import c.universe._
+    c.Expr(Literal(Constant(false)))
+  }
+
+  def isJsImpl(c: Context): c.Expr[Boolean] = {
+    import c.universe._
+    c.Expr(Literal(Constant(true)))
+  }
+}

macros/jvm/src/main/scala/cats/macros/Platform.scala

@@ -0,0 +1,18 @@
+package cats.macros
+
+import scala.reflect.macros.Context
+
+object Platform {
+  def isJvm: Boolean = macro isJvmImpl
+  def isJs: Boolean = macro isJsImpl
+
+  def isJvmImpl(c: Context): c.Expr[Boolean] = {
+    import c.universe._
+    c.Expr(Literal(Constant(true)))
+  }
+
+  def isJsImpl(c: Context): c.Expr[Boolean] = {
+    import c.universe._
+    c.Expr(Literal(Constant(false)))
+  }
+}