Introduce cats-kernel and remove algebra dependency

build.sbt

@@ -25,12 +25,11 @@ lazy val catsDoctestSettings = Seq(
 ) ++ doctestSettings
 
 lazy val kernelSettings = Seq(
-  scalacOptions ++= commonScalacOptions,
+  scalacOptions ++= commonScalacOptions.filter(_ != "-Ywarn-value-discard"),
   resolvers ++= Seq(
     "bintray/non" at "http://dl.bintray.com/non/maven",
     Resolver.sonatypeRepo("releases"),
-    Resolver.sonatypeRepo("snapshots")
-  ),
+    Resolver.sonatypeRepo("snapshots")),
   parallelExecution in Test := false,
   scalacOptions in (Compile, doc) := (scalacOptions in (Compile, doc)).value.filter(_ != "-Xfatal-warnings")
 ) ++ warnUnusedImport

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

@@ -1,8 +1,6 @@
 package cats
 package std
 
-import cats.kernel.CommutativeGroup
-
 trait AnyValInstances
   extends IntInstances
   with    ByteInstances
@@ -15,102 +13,37 @@ trait AnyValInstances
   with    UnitInstances
 
 trait IntInstances extends cats.kernel.std.IntInstances {
-
-  implicit val intShow: Show[Int] =
-    Show.fromToString[Int]
-
-  implicit val intGroup: CommutativeGroup[Int] =
-    new CommutativeGroup[Int] {
-      def combine(x: Int, y: Int): Int = x + y
-      def empty: Int = 0
-      def inverse(x: Int): Int = -x
-      override def remove(x: Int, y: Int): Int = x - y
-    }
+  implicit val intShow: Show[Int] = Show.fromToString[Int]
 }
 
 trait ByteInstances extends cats.kernel.std.ByteInstances {
-
-  implicit val byteShow: Show[Byte] =
-    Show.fromToString[Byte]
-
-  implicit val byteGroup: CommutativeGroup[Byte] =
-    new CommutativeGroup[Byte] {
-      def combine(x: Byte, y: Byte): Byte = (x + y).toByte
-      def empty: Byte = 0
-      def inverse(x: Byte): Byte = (-x).toByte
-      override def remove(x: Byte, y: Byte): Byte = (x - y).toByte
-    }
+  implicit val byteShow: Show[Byte] = Show.fromToString[Byte]
 }
 
 trait CharInstances extends cats.kernel.std.CharInstances {
-  implicit val charShow: Show[Char] =
-    Show.fromToString[Char]
+  implicit val charShow: Show[Char] = Show.fromToString[Char]
 }
 
 trait ShortInstances extends cats.kernel.std.ShortInstances {
-
-  implicit val shortShow: Show[Short] =
-    Show.fromToString[Short]
-
-  implicit val shortGroup: CommutativeGroup[Short] =
-    new CommutativeGroup[Short] {
-      def combine(x: Short, y: Short): Short = (x + y).toShort
-      def empty: Short = 0
-      def inverse(x: Short): Short = (-x).toShort
-      override def remove(x: Short, y: Short): Short = (x - y).toShort
-    }
+  implicit val shortShow: Show[Short] = Show.fromToString[Short]
 }
 
 trait LongInstances extends cats.kernel.std.LongInstances {
-
-  implicit val longShow: Show[Long] =
-    Show.fromToString[Long]
-
-  implicit val longGroup: CommutativeGroup[Long] =
-    new CommutativeGroup[Long] {
-      def combine(x: Long, y: Long): Long = x + y
-      def empty: Long = 0L
-      def inverse(x: Long): Long = -x
-      override def remove(x: Long, y: Long): Long = x - y
-    }
+  implicit val longShow: Show[Long] = Show.fromToString[Long]
 }
 
 trait FloatInstances extends cats.kernel.std.FloatInstances {
-
-  implicit val floatShow: Show[Float] =
-    Show.fromToString[Float]
-
-  implicit val floatGroup: CommutativeGroup[Float] =
-    new CommutativeGroup[Float] {
-      def combine(x: Float, y: Float): Float = x + y
-      def empty: Float = 0F
-      def inverse(x: Float): Float = -x
-      override def remove(x: Float, y: Float): Float = x - y
-    }
+  implicit val floatShow: Show[Float] = Show.fromToString[Float]
 }
 
 trait DoubleInstances extends cats.kernel.std.DoubleInstances {
-
-  implicit val doubleShow: Show[Double] =
-    Show.fromToString[Double]
-
-  implicit val doubleGroup: CommutativeGroup[Double] =
-    new CommutativeGroup[Double] {
-      def combine(x: Double, y: Double): Double = x + y
-      def empty: Double = 0D
-      def inverse(x: Double): Double = -x
-      override def remove(x: Double, y: Double): Double = x - y
-    }
+  implicit val doubleShow: Show[Double] = Show.fromToString[Double]
 }
 
 trait BooleanInstances extends cats.kernel.std.BooleanInstances {
-
-  implicit val booleanShow: Show[Boolean] =
-    Show.fromToString[Boolean]
+  implicit val booleanShow: Show[Boolean] = Show.fromToString[Boolean]
 }
 
 trait UnitInstances extends cats.kernel.std.UnitInstances {
-
-  implicit val unitShow: Show[Unit] =
-    Show.fromToString[Unit]
+  implicit val unitShow: Show[Unit] = Show.fromToString[Unit]
 }

kernel-laws/src/main/scala/cats/kernel/laws/GroupLaws.scala

@@ -81,45 +81,6 @@ trait GroupLaws[A] extends Laws {
     parents = List(group, commutativeMonoid)
   )
 
-  // // additive groups
-  // 
-  // def additiveSemigroup(implicit A: AdditiveSemigroup[A]) = new AdditiveProperties(
-  //   base = semigroup(A.additive),
-  //   parents = Nil,
-  //   Rules.serializable(A),
-  //   Rules.repeat1("sumN")(A.sumN),
-  //   Rules.repeat2("sumN", "+")(A.sumN)(A.plus)
-  // )
-  // 
-  // def additiveCommutativeSemigroup(implicit A: AdditiveCommutativeSemigroup[A]) = new AdditiveProperties(
-  //   base = commutativeSemigroup(A.additive),
-  //   parents = List(additiveSemigroup)
-  // )
-  // 
-  // def additiveMonoid(implicit A: AdditiveMonoid[A]) = new AdditiveProperties(
-  //   base = monoid(A.additive),
-  //   parents = List(additiveSemigroup),
-  //   Rules.repeat0("sumN", "zero", A.zero)(A.sumN),
-  //   Rules.collect0("sum", "zero", A.zero)(A.sum)
-  // )
-  // 
-  // def additiveCommutativeMonoid(implicit A: AdditiveCommutativeMonoid[A]) = new AdditiveProperties(
-  //   base = commutativeMonoid(A.additive),
-  //   parents = List(additiveMonoid)
-  // )
-  // 
-  // def additiveGroup(implicit A: AdditiveGroup[A]) = new AdditiveProperties(
-  //   base = group(A.additive),
-  //   parents = List(additiveMonoid),
-  //   Rules.consistentInverse("subtract")(A.minus)(A.plus)(A.negate)
-  // )
-  // 
-  // def additiveCommutativeGroup(implicit A: AdditiveCommutativeGroup[A]) = new AdditiveProperties(
-  //   base = commutativeGroup(A.additive),
-  //   parents = List(additiveGroup)
-  // )
-
-
   // property classes
 
   class GroupProperties(
@@ -129,14 +90,4 @@ trait GroupLaws[A] extends Laws {
   ) extends RuleSet {
     val bases = Nil
   }
-
-  // class AdditiveProperties(
-  //   val base: GroupProperties,
-  //   val parents: Seq[AdditiveProperties],
-  //   val props: (String, Prop)*
-  // ) extends RuleSet {
-  //   val name = base.name
-  //   val bases = List("base" -> base)
-  // }
-
 }

kernel-laws/src/main/scala/cats/kernel/laws/package.scala

@@ -8,7 +8,7 @@ import Prop.{False, Proof, Result}
 
 package object laws {
 
-  implicit def PredicateFromMonoid[A](implicit ev: Eq[A], A: Monoid[A]): Predicate[A] =
+  implicit def nonEmptyPredicate[A](implicit ev: Eq[A], A: Monoid[A]): Predicate[A] =
     new Predicate[A] {
       def apply(a: A) = ev.neqv(a, A.empty)
     }

kernel/src/main/scala/cats/kernel/Group.scala

@@ -25,11 +25,24 @@ trait Group[@sp(Int, Long, Float, Double) A] extends Any with Monoid[A] {
    * Return `a` appended to itself `n` times. If `n` is negative, then
    * this returns `inverse(a)` appended to itself `n` times.
    */
-  override def combineN(a: A, n: Int): A =
+  override def combineN(a: A, n: Int): A = {
+    // This method is a bit tricky. Normally, to sum x a negative
+    // number of times (n), we can sum (-x) a positive number of times
+    // (-n). The issue here is that Int.MinValue cannot be negated; in
+    // other words (-MinValue) == MinValue.
+    //
+    // To work around that, we rely on the fact that we can divide n
+    // by 2 if we sum 2a (i.e. combine(a, a)) instead. Here is the
+    // transformation we use:
+    //
+    //   combineN(x, -2147483648)
+    //   combineN(combine(x, x), -1073741824)
+    //   combineN(inverse(combine(x, x)), 1073741824)
     if (n > 0) repeatedCombineN(a, n)
     else if (n == 0) empty
     else if (n == Int.MinValue) combineN(inverse(combine(a, a)), 1073741824)
     else repeatedCombineN(inverse(a), -n)
+  }
 }
 
 trait GroupFunctions[G[T] <: Group[T]] extends MonoidFunctions[Group] {

kernel/src/main/scala/cats/kernel/Order.scala

@@ -177,13 +177,14 @@ object Order extends OrderFunctions {
   /**
    * An `Order` instance that considers all `A` instances to be equal.
    */
-  def allEqual[A]: Order[A] = new Order[A] {
-    def compare(x: A, y: A): Int = 0
-  }
+  def allEqual[A]: Order[A] =
+    new Order[A] {
+      def compare(x: A, y: A): Int = 0
+    }
 
 
   /**
-   * A `Monoid[Order[A]]` can be generated for all `A` with the following
+   * A `Band[Order[A]]` can be generated for all `A` with the following
    * properties:
    *
    * `empty` returns a trivial `Order[A]` which considers all `A` instances to
@@ -194,16 +195,16 @@ object Order extends OrderFunctions {
    *
    * @see [[Order.whenEqual]]
    */
-  def whenEqualMonoid[A]: Monoid[Order[A]] =
-    new Monoid[Order[A]] {
+  def whenEqualMonoid[A]: Band[Order[A]] =
+    new Band[Order[A]] {
       val empty: Order[A] = allEqual[A]
-
       def combine(x: Order[A], y: Order[A]): Order[A] = x whenEqual y
     }
 
-  def fromOrdering[A](implicit ev: Ordering[A]): Order[A] = new Order[A] {
-    def compare(x: A, y: A): Int = ev.compare(x, y)
+  def fromOrdering[A](implicit ev: Ordering[A]): Order[A] =
+    new Order[A] {
+      def compare(x: A, y: A): Int = ev.compare(x, y)
 
-    override def toOrdering: Ordering[A] = ev
-  }
+      override def toOrdering: Ordering[A] = ev
+    }
 }

kernel/src/main/scala/cats/kernel/std/bigInt.scala

@@ -6,6 +6,15 @@ package object bigInt extends BigIntInstances
 trait BigIntInstances {
   implicit val bigIntOrder: Order[BigInt] =
     new BigIntOrder
+  implicit val bigIntGroup: CommutativeGroup[BigInt] =
+    new BigIntGroup
+}
+
+class BigIntGroup extends CommutativeGroup[BigInt] {
+  val empty: BigInt = BigInt(0)
+  def combine(x: BigInt, y: BigInt): BigInt = x + y
+  def inverse(x: BigInt): BigInt = -x
+  override def remove(x: BigInt, y: BigInt): BigInt = x - y
 }
 
 class BigIntOrder extends Order[BigInt] {

kernel/src/main/scala/cats/kernel/std/boolean.scala

@@ -4,7 +4,7 @@ package std
 package object boolean extends BooleanInstances
 
 trait BooleanInstances {
-  implicit val booleanOrder: BooleanOrder =
+  implicit val booleanOrder: Order[Boolean] =
     new BooleanOrder
 }
 

kernel/src/main/scala/cats/kernel/std/byte.scala

@@ -5,6 +5,14 @@ package object byte extends ByteInstances
 
 trait ByteInstances {
   implicit val byteOrder: Order[Byte] = new ByteOrder
+  implicit val byteGroup: CommutativeGroup[Byte] = new ByteGroup
+}
+
+class ByteGroup extends CommutativeGroup[Byte] {
+  def combine(x: Byte, y: Byte): Byte = (x + y).toByte
+  def empty: Byte = 0
+  def inverse(x: Byte): Byte = (-x).toByte
+  override def remove(x: Byte, y: Byte): Byte = (x - y).toByte
 }
 
 class ByteOrder extends Order[Byte] {

kernel/src/main/scala/cats/kernel/std/double.scala

@@ -5,6 +5,14 @@ import java.lang.Math
 
 trait DoubleInstances {
   implicit val doubleOrder: Order[Double] = new DoubleOrder
+  implicit val doubleGroup: CommutativeGroup[Double] = new DoubleGroup
+}
+
+class DoubleGroup extends CommutativeGroup[Double] {
+  def combine(x: Double, y: Double): Double = x + y
+  def empty: Double = 0D
+  def inverse(x: Double): Double = -x
+  override def remove(x: Double, y: Double): Double = x - y
 }
 
 class DoubleOrder extends Order[Double] {

kernel/src/main/scala/cats/kernel/std/float.scala

@@ -2,7 +2,18 @@ package cats.kernel
 package std
 
 trait FloatInstances {
-  implicit val floatOrder = new FloatOrder
+  implicit val floatOrder: Order[Float] = new FloatOrder
+  implicit val floatGroup: CommutativeGroup[Float] = new FloatGroup
+}
+
+/**
+ * This is only approximately associative.
+ */
+class FloatGroup extends CommutativeGroup[Float] {
+  def combine(x: Float, y: Float): Float = x + y
+  def empty: Float = 0F
+  def inverse(x: Float): Float = -x
+  override def remove(x: Float, y: Float): Float = x - y
 }
 
 /**

kernel/src/main/scala/cats/kernel/std/int.scala

@@ -5,6 +5,14 @@ package object int extends IntInstances
 
 trait IntInstances {
   implicit val intOrder: Order[Int] = new IntOrder
+  implicit val intGroup: CommutativeGroup[Int] = new IntGroup
+}
+
+class IntGroup extends CommutativeGroup[Int] {
+  def combine(x: Int, y: Int): Int = x + y
+  def empty: Int = 0
+  def inverse(x: Int): Int = -x
+  override def remove(x: Int, y: Int): Int = x - y
 }
 
 class IntOrder extends Order[Int] {

kernel/src/main/scala/cats/kernel/std/long.scala

@@ -4,7 +4,15 @@ package std
 package object long extends LongInstances
 
 trait LongInstances {
-  implicit val longOrder = new LongOrder
+  implicit val longOrder: Order[Long] = new LongOrder
+  implicit val longGroup: CommutativeGroup[Long] = new LongGroup
+}
+
+class LongGroup extends CommutativeGroup[Long] {
+  def combine(x: Long, y: Long): Long = x + y
+  def empty: Long = 0L
+  def inverse(x: Long): Long = -x
+  override def remove(x: Long, y: Long): Long = x - y
 }
 
 class LongOrder extends Order[Long] {