WIP: Switch laws to cats-core encoding

build.sbt

@@ -7,13 +7,13 @@ import com.typesafe.tools.mima.plugin.MimaPlugin.mimaDefaultSettings
 lazy val scalaCheckVersion = "1.13.4"
 lazy val scalaTestVersion = "3.0.1"
 lazy val disciplineVersion = "0.7.2"
-lazy val catsVersion = "1.0.0-MF"
+lazy val catsVersion = "1.0.0-RC1"
 lazy val catalystsVersion = "0.0.5"
 
 lazy val buildSettings = Seq(
   organization := "org.typelevel",
-  scalaVersion := "2.12.3",
-  crossScalaVersions := Seq("2.10.6", "2.11.11", "2.12.3")
+  scalaVersion := "2.12.4",
+  crossScalaVersions := Seq("2.10.6", "2.11.11", "2.12.4")
 )
 
 lazy val commonSettings = Seq(

laws/src/main/scala/algebra/laws/AdditiveCommutativeGroupLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait AdditiveCommutativeGroupLaws[A] extends AdditiveGroupLaws[A] with AdditiveCommutativeMonoidLaws[A] {
+  override implicit def S: AdditiveCommutativeGroup[A]
+}
+
+object AdditiveCommutativeGroupLaws {
+  def apply[A](implicit ev: AdditiveCommutativeGroup[A]): AdditiveCommutativeGroupLaws[A] =
+    new AdditiveCommutativeGroupLaws[A] { def S: AdditiveCommutativeGroup[A] = ev }
+}

laws/src/main/scala/algebra/laws/AdditiveCommutativeMonoidLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait AdditiveCommutativeMonoidLaws[A] extends AdditiveMonoidLaws[A] with AdditiveCommutativeSemigroupLaws[A] {
+  override implicit def S: AdditiveCommutativeMonoid[A]
+}
+
+object AdditiveCommutativeMonoidLaws {
+  def apply[A](implicit ev: AdditiveCommutativeMonoid[A]): AdditiveCommutativeMonoidLaws[A] =
+  new AdditiveCommutativeMonoidLaws[A] { def S: AdditiveCommutativeMonoid[A] = ev }
+}

laws/src/main/scala/algebra/laws/AdditiveCommutativeSemigroupLaws.scala

@@ -0,0 +1,19 @@
+package algebra
+package laws
+
+import algebra.ring._
+import cats.kernel.laws._
+
+
+trait AdditiveCommutativeSemigroupLaws[A] extends AdditiveSemigroupLaws[A] {
+  override implicit def S: AdditiveCommutativeSemigroup[A]
+
+  def plusCommutative(x: A, y: A): IsEq[A] =
+    S.plus(x, y) <-> S.plus(y, x)
+
+}
+
+object AdditiveCommutativeSemigroupLaws {
+  def apply[A](implicit ev: AdditiveCommutativeSemigroup[A]): AdditiveCommutativeSemigroupLaws[A] =
+    new AdditiveCommutativeSemigroupLaws[A] { def S: AdditiveCommutativeSemigroup[A] = ev }
+}

laws/src/main/scala/algebra/laws/AdditiveGroupLaws.scala

@@ -0,0 +1,25 @@
+package algebra
+package laws
+
+import algebra.ring._
+import cats.kernel.laws._
+
+
+trait AdditiveGroupLaws[A] extends AdditiveMonoidLaws[A] {
+  override implicit def S: AdditiveGroup[A]
+
+  def leftNegate(x: A): IsEq[A] =
+    S.plus(S.negate(x), x) <-> S.zero
+
+  def rightNegate(x: A): IsEq[A] =
+    S.plus(x, S.negate(x)) <-> S.zero
+
+  def consistentMinus(x: A, y: A): IsEq[A] =
+    S.minus(x, y) <-> S.plus(x, S.negate(y))
+
+}
+
+object AdditiveGroupLaws {
+  def apply[A](implicit ev: AdditiveGroup[A]): AdditiveGroupLaws[A] =
+    new AdditiveGroupLaws[A] { def S: AdditiveGroup[A] = ev }
+}

laws/src/main/scala/algebra/laws/AdditiveMonoidLaws.scala

@@ -0,0 +1,29 @@
+package algebra.laws
+
+import algebra.ring._
+import cats.kernel.Eq
+import cats.kernel.laws._
+
+trait AdditiveMonoidLaws[A] extends AdditiveSemigroupLaws[A] {
+  override implicit def S: AdditiveMonoid[A]
+
+  def leftZero(a: A): IsEq[A] =
+    S.plus(S.zero, a) <-> a
+
+  def rightZero(a: A): IsEq[A] =
+    S.plus(a, S.zero) <-> a
+
+  def sumN0(a: A): IsEq[A] =
+    S.sumN(a, 0) <-> S.zero
+
+  def sumAll: IsEq[A] =
+    S.sum(Nil) <-> S.zero
+
+  def isZero(a: A, eqv: Eq[A]): IsEq[Boolean] =
+    eqv.eqv(a, S.zero) <-> S.isZero(a)(eqv)
+}
+
+object AdditiveMonoidLaws {
+  def apply[A](implicit ev: AdditiveMonoid[A]): AdditiveMonoidLaws[A] =
+    new AdditiveMonoidLaws[A] { def S: AdditiveMonoid[A] = ev }
+}

laws/src/main/scala/algebra/laws/AdditiveSemigroupLaws.scala

@@ -0,0 +1,29 @@
+package algebra
+package laws
+
+import algebra.ring._
+import cats.kernel.laws._
+
+trait AdditiveSemigroupLaws[A] {
+  implicit def S: AdditiveSemigroup[A]
+
+  def plusAssociative(x: A, y: A, z: A): IsEq[A] =
+    S.plus(S.plus(x, y), z) <-> S.plus(x, S.plus(y, z))
+
+  def sumN1(a: A): IsEq[A] =
+    S.sumN(a, 1) <-> a
+
+  def sumN2(a: A): IsEq[A] =
+    S.sumN(a, 2) <-> S.plus(a, a)
+
+  def sumN3(a: A): IsEq[A] =
+    S.sumN(a, 3) <-> S.plus(S.plus(a, a), a)
+
+  def trySum(xs: Vector[A]): IsEq[Option[A]] =
+    S.trySum(xs) <-> xs.reduceOption(S.plus)
+}
+
+object AdditiveSemigroupLaws {
+  def apply[A](implicit ev: AdditiveSemigroup[A]): AdditiveSemigroupLaws[A] =
+    new AdditiveSemigroupLaws[A] { def S: AdditiveSemigroup[A] = ev }
+}

laws/src/main/scala/algebra/laws/BoundedDistributiveLatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.lattice._
+
+trait BoundedDistributiveLatticeLaws[A] extends BoundedLatticeLaws[A] with DistributiveLatticeLaws[A] {
+  override implicit def S: BoundedDistributiveLattice[A]
+}
+
+object BoundedDistributiveLatticeLaws {
+  def apply[A](implicit ev: BoundedDistributiveLattice[A]): BoundedDistributiveLatticeLaws[A] =
+    new BoundedDistributiveLatticeLaws[A] { def S: BoundedDistributiveLattice[A] = ev }
+}

laws/src/main/scala/algebra/laws/BoundedJoinLatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.lattice._
+
+trait BoundedJoinLatticeLaws[A] extends LatticeLaws[A] with BoundedJoinSemilatticeLaws[A] {
+  override implicit def S: Lattice[A] with BoundedJoinSemilattice[A]
+}
+
+object BoundedJoinLatticeLaws {
+  def apply[A](implicit ev: Lattice[A] with BoundedJoinSemilattice[A]): BoundedJoinLatticeLaws[A] =
+    new BoundedJoinLatticeLaws[A] { def S: Lattice[A] with BoundedJoinSemilattice[A] = ev }
+}

laws/src/main/scala/algebra/laws/BoundedJoinSemilatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra.laws
+
+import algebra.lattice._
+import cats.kernel.laws.BoundedSemilatticeLaws
+
+trait BoundedJoinSemilatticeLaws[A] extends JoinSemilatticeLaws[A] with BoundedSemilatticeLaws[A] {
+  override implicit def S: BoundedJoinSemilattice[A]
+}
+
+object BoundedJoinSemilatticeLaws {
+  def apply[A](implicit ev: BoundedJoinSemilattice[A]): BoundedJoinSemilatticeLaws[A] =
+    new BoundedJoinSemilatticeLaws[A] { def S: BoundedJoinSemilattice[A] = ev }
+}

laws/src/main/scala/algebra/laws/BoundedLatticeLaws.scala

@@ -0,0 +1,14 @@
+package algebra
+package laws
+
+import algebra.lattice._
+
+trait BoundedLatticeLaws[A] extends LatticeLaws[A] with BoundedMeetLatticeLaws[A] with BoundedJoinLatticeLaws[A] {
+  override implicit def S: BoundedLattice[A]
+}
+
+object BoundedLatticeLaws {
+  def apply[A](implicit ev: BoundedLattice[A]): BoundedLatticeLaws[A] =
+    new BoundedLatticeLaws[A] { def S: BoundedLattice[A] = ev }
+}
+

laws/src/main/scala/algebra/laws/BoundedMeetLatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra.laws
+
+import algebra.lattice._
+
+trait BoundedMeetLatticeLaws[A] extends LatticeLaws[A] with BoundedMeetSemilatticeLaws[A] {
+  override implicit def S: Lattice[A] with BoundedMeetSemilattice[A]
+}
+
+object BoundedMeetLatticeLaws {
+  def apply[A](implicit ev: Lattice[A] with BoundedMeetSemilattice[A]): BoundedMeetLatticeLaws[A] =
+    new BoundedMeetLatticeLaws[A] { def S: Lattice[A] with BoundedMeetSemilattice[A] = ev }
+}
+

laws/src/main/scala/algebra/laws/BoundedMeetSemilatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra.laws
+
+import cats.kernel.laws.BoundedSemilatticeLaws
+import algebra.lattice._
+
+trait BoundedMeetSemilatticeLaws[A] extends MeetSemilatticeLaws[A] with BoundedSemilatticeLaws[A] {
+  override implicit def S: BoundedMeetSemilattice[A]
+}
+
+object BoundedMeetSemilatticeLaws {
+  def apply[A](implicit ev: BoundedMeetSemilattice[A]): BoundedMeetSemilatticeLaws[A] =
+    new BoundedMeetSemilatticeLaws[A] { def S: BoundedMeetSemilattice[A] = ev }
+}

laws/src/main/scala/algebra/laws/CommutativeRigLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait CommutativeRigLaws[A] extends RigLaws[A] with CommutativeSemiringLaws[A] with MultiplicativeCommutativeMonoidLaws[A] {
+  override implicit def S: CommutativeRig[A]
+}
+
+object CommutativeRigLaws {
+  def apply[A](implicit ev: CommutativeRig[A]): CommutativeRigLaws[A] =
+    new CommutativeRigLaws[A] { def S: CommutativeRig[A] = ev }
+}

laws/src/main/scala/algebra/laws/CommutativeRingLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait CommutativeRingLaws[A] extends RingLaws[A] with CommutativeRigLaws[A] with CommutativeRngLaws[A] {
+  override implicit def S: CommutativeRing[A]
+}
+
+object CommutativeRingLaws {
+  def apply[A](implicit ev: CommutativeRing[A]): CommutativeRingLaws[A] =
+    new CommutativeRingLaws[A] { def S: CommutativeRing[A] = ev }
+}

laws/src/main/scala/algebra/laws/CommutativeRngLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait CommutativeRngLaws[A] extends CommutativeSemiringLaws[A] with RngLaws[A] {
+  override implicit def S: CommutativeRng[A]
+}
+
+object CommutativeRngLaws {
+  def apply[A](implicit ev: CommutativeRng[A]): CommutativeRngLaws[A] =
+    new CommutativeRngLaws[A] { def S: CommutativeRng[A] = ev }
+}

laws/src/main/scala/algebra/laws/CommutativeSemiringLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait CommutativeSemiringLaws[A] extends SemiringLaws[A] with MultiplicativeCommutativeSemigroupLaws[A] {
+  override implicit def S: CommutativeSemiring[A]
+}
+
+object CommutativeSemiringLaws {
+  def apply[A](implicit ev: CommutativeSemiring[A]): CommutativeSemiringLaws[A] =
+    new CommutativeSemiringLaws[A] { def S: CommutativeSemiring[A] = ev }
+}

laws/src/main/scala/algebra/laws/DistributiveLatticeLaws.scala

@@ -0,0 +1,20 @@
+package algebra
+package laws
+
+import algebra.lattice._
+import cats.kernel.laws._
+
+
+trait DistributiveLatticeLaws[A] extends LatticeLaws[A] {
+  override implicit def S: DistributiveLattice[A]
+
+  def distributive(x: A, y: A, z: A)(implicit E: Eq[A]): IsEq[Boolean] =
+    (E.eqv(S.join(x, S.meet(y, z)), S.meet(S.join(x, y), S.join(x, z))) &&
+      E.eqv(S.meet(x, S.join(y, z)), S.join(S.meet(x, y), S.meet(x, z)))) <-> true
+
+}
+
+object DistributiveLatticeLaws {
+  def apply[A](implicit ev: DistributiveLattice[A]): DistributiveLatticeLaws[A] =
+    new DistributiveLatticeLaws[A] { def S: DistributiveLattice[A] = ev }
+}

laws/src/main/scala/algebra/laws/FieldLaws.scala

@@ -0,0 +1,13 @@
+package algebra
+package laws
+
+import algebra.ring._
+
+trait FieldLaws[A] extends CommutativeRingLaws[A] with MultiplicativeCommutativeGroupLaws[A] {
+  override implicit def S: Field[A]
+}
+
+object FieldLaws {
+  def apply[A: Field]: FieldLaws[A] =
+    new FieldLaws[A] { def S: Field[A] = implicitly }
+}

laws/src/main/scala/algebra/laws/HeytingLaws.scala

@@ -0,0 +1,19 @@
+package algebra.laws
+
+import algebra._
+import algebra.lattice._
+
+import cats.kernel.laws._
+
+
+trait HeytingLaws[A] extends BoundedDistributiveLatticeLaws[A] {
+  override implicit def S: Heyting[A]
+
+  def absorption(x: A, y: A)(implicit E: Eq[A]): IsEq[Boolean] =
+    (E.eqv(S.join(x, S.meet(x, y)), x) && E.eqv(S.meet(x, S.join(x, y)), x)) <-> true
+}
+
+object HeytingLaws {
+  def apply[A](implicit ev: Heyting[A]): HeytingLaws[A] =
+    new HeytingLaws[A] { def S: Heyting[A] = ev }
+}

laws/src/main/scala/algebra/laws/JoinSemilatticeLaws.scala

@@ -0,0 +1,13 @@
+package algebra.laws
+
+import algebra.lattice.JoinSemilattice
+import cats.kernel.laws.SemilatticeLaws
+
+trait JoinSemilatticeLaws[A] extends SemilatticeLaws[A] {
+  override implicit def S: JoinSemilattice[A]
+}
+
+object JoinSemilatticeLaws {
+  def apply[A](implicit ev: JoinSemilattice[A]): JoinSemilatticeLaws[A] =
+    new JoinSemilatticeLaws[A] { def S: JoinSemilattice[A] = ev }
+}