update: address compiler errors and warnings

Author: i10416

algebird-test/src/main/scala/com/twitter/algebird/scalacheck/Gen.scala

@@ -47,9 +47,9 @@ object gen extends ExpHistGen with IntervalGen {
     for {
       m0 <- choose(1L, Int.MaxValue.toLong)
       m1 <- choose(-1e50, 1e50)
-      m2 <- choose(0, 1e50)
+      m2 <- choose[Double](0, 1e50)
       m3 <- choose(-1e10, 1e50)
-      m4 <- choose(0, 1e50)
+      m4 <- choose[Double](0, 1e50)
     } yield new Moments(m0, m1, m2, m3, m4)
 
   private val genLongString: Gen[String] = for {
@@ -91,8 +91,8 @@ object gen extends ExpHistGen with IntervalGen {
     val genRandom: Gen[Correlation] =
       for {
         c2 <- choose(-1e10, 1e10)
-        m2x <- choose(0, 1e10)
-        m2y <- choose(0, 1e10)
+        m2x <- choose[Double](0, 1e10)
+        m2y <- choose[Double](0, 1e10)
         m1x <- choose(-1e10, 1e10)
         m1y <- choose(-1e10, 1e10)
         m0 <- choose(-1e10, 1e10)

algebird-test/src/test/scala-2.11/com/twitter/algebird/CMSContraMapSpecCompat.scala

@@ -0,0 +1,37 @@
+package com.twitter.algebird
+
+import org.scalatestplus.scalacheck.{ScalaCheckDrivenPropertyChecks, ScalaCheckPropertyChecks}
+import org.scalacheck.{Arbitrary, Gen}
+
+import scala.util.Random
+import CMSHasherImplicits.CMSHasherBigInt
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.propspec.AnyPropSpec
+import org.scalatest.wordspec.AnyWordSpec
+
+trait CMSContraMapSpecCompat { self: AnyWordSpec with Matchers with ScalaCheckDrivenPropertyChecks =>
+  "translates CMSHasher[K] into CMSHasher[L], given a function f: L => K" in {
+    // Given a "source" CMSHasher[K]
+    val sourceHasher: CMSHasher[String] = CMSHasher.CMSHasherString
+    // and a translation function from an unsupported type L (here: Seq[Byte]) to K
+    def f(bytes: Seq[Byte]): String = new String(bytes.toArray[Byte], "UTF-8")
+
+    // When we run contramap on a CMSHasher[K] supplying f,
+    // then the result should be a CMSHasher[L]...
+    val targetHasher: CMSHasher[Seq[Byte]] =
+      sourceHasher.contramap((d: Seq[Byte]) => f(d))
+    targetHasher shouldBe an[CMSHasher[
+      _
+    ]] // Can't test CMSHasher[Seq[Byte]] specifically because of type erasure.
+
+    // ...and hashing should work correctly (this is only a smoke test).
+    val a = 4
+    val b = 0
+    val width = 1234
+    val x = Array(113.toByte).toSeq // same as Seq(133.toByte)
+    val result = targetHasher.hash(a, b, width)(x)
+    val expected = sourceHasher.hash(a, b, width)("q")
+    result should be(expected)
+    result should be(434)
+  }
+}

algebird-test/src/test/scala-2.11/com/twitter/algebird/IntervalLawsCompat.scala

@@ -0,0 +1,38 @@
+package com.twitter.algebird
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Prop._
+import org.scalacheck.Prop
+import org.scalatest.funsuite.AnyFunSuite
+
+trait IntervalLawsCompat { self: CheckProperties =>
+  import com.twitter.algebird.scalacheck.arbitrary._
+  import com.twitter.algebird.Interval.GenIntersection
+  property("if boundedLeast is none, we are Universe, Upper or isEmpty is true") {
+    forAll { (a: Interval[Long]) =>
+      a.boundedLeast match {
+        case Some(_) => true
+        case None =>
+          a.isEmpty || (a match {
+            case _: Upper[_] => true
+            case Universe()  => true
+            case _           => false
+          })
+      }
+    }
+  }
+  property("if boundedGreatest is none, we are Universe, Lower or isEmpty is true") {
+    forAll { (a: Interval[Long]) =>
+      a.boundedGreatest match {
+        case Some(_) => true
+        case None =>
+          a.isEmpty || (a match {
+            case _: Lower[_] => true
+            case Universe()  => true
+            case _           => false
+          })
+      }
+    }
+  }
+
+}

algebird-test/src/test/scala-2.12+/com/twitter/algebird/AggregatorLaws.scala

@@ -126,7 +126,7 @@ class AggregatorLaws extends CheckProperties {
   }
 
   def checkNumericSum[T: Arbitrary](implicit num: Numeric[T]): Prop =
-    forAll { in: List[T] =>
+    forAll { (in: List[T]) =>
       val aggregator = Aggregator.numericSum[T]
       val ares = aggregator(in)
       val sres = in.map(num.toDouble).sum

algebird-test/src/test/scala-2.12+/com/twitter/algebird/CMSContraMapSpecCompat.scala

@@ -0,0 +1,37 @@
+package com.twitter.algebird
+
+import org.scalatestplus.scalacheck.{ScalaCheckDrivenPropertyChecks, ScalaCheckPropertyChecks}
+import org.scalacheck.{Arbitrary, Gen}
+
+import scala.util.Random
+import CMSHasherImplicits.CMSHasherBigInt
+import org.scalatest.matchers.should.Matchers
+import org.scalatest.propspec.AnyPropSpec
+import org.scalatest.wordspec.AnyWordSpec
+
+trait CMSContraMapSpecCompat { self: AnyWordSpec with Matchers with ScalaCheckDrivenPropertyChecks =>
+  "translates CMSHasher[K] into CMSHasher[L], given a function f: L => K" in {
+    // Given a "source" CMSHasher[K]
+    val sourceHasher: CMSHasher[String] = CMSHasher.CMSHasherString
+    // and a translation function from an unsupported type L (here: Seq[Byte]) to K
+    def f(bytes: Seq[Byte]): String = new String(bytes.toArray[Byte], "UTF-8")
+
+    // When we run contramap on a CMSHasher[K] supplying f,
+    // then the result should be a CMSHasher[L]...
+    val targetHasher: CMSHasher[Seq[Byte]] =
+      sourceHasher.contramap((d: Seq[Byte]) => f(d))
+    targetHasher shouldBe an[CMSHasher[
+      ?
+    ]] // Can't test CMSHasher[Seq[Byte]] specifically because of type erasure.
+
+    // ...and hashing should work correctly (this is only a smoke test).
+    val a = 4
+    val b = 0
+    val width = 1234
+    val x = Array(113.toByte).toSeq // same as Seq(133.toByte)
+    val result = targetHasher.hash(a, b, width)(x)
+    val expected = sourceHasher.hash(a, b, width)("q")
+    result should be(expected)
+    result should be(434)
+  }
+}

algebird-test/src/test/scala-2.12+/com/twitter/algebird/IntervalLawsCompat.scala

@@ -0,0 +1,38 @@
+package com.twitter.algebird
+
+import org.scalacheck.Arbitrary
+import org.scalacheck.Prop._
+import org.scalacheck.Prop
+import org.scalatest.funsuite.AnyFunSuite
+
+trait IntervalLawsCompat { self: CheckProperties =>
+  import com.twitter.algebird.scalacheck.arbitrary._
+  import com.twitter.algebird.Interval.GenIntersection
+  property("if boundedLeast is none, we are Universe, Upper or isEmpty is true") {
+    forAll { (a: Interval[Long]) =>
+      a.boundedLeast match {
+        case Some(_) => true
+        case None =>
+          a.isEmpty || (a match {
+            case _: Upper[?] => true
+            case Universe()  => true
+            case _           => false
+          })
+      }
+    }
+  }
+  property("if boundedGreatest is none, we are Universe, Lower or isEmpty is true") {
+    forAll { (a: Interval[Long]) =>
+      a.boundedGreatest match {
+        case Some(_) => true
+        case None =>
+          a.isEmpty || (a match {
+            case _: Lower[?] => true
+            case Universe()  => true
+            case _           => false
+          })
+      }
+    }
+  }
+
+}

algebird-test/src/test/scala/com/twitter/algebird/CheckProperties.scala renamed to algebird-test/src/test/scala-2/com/twitter/algebird/CheckProperties.scala

@@ -0,0 +1,10 @@
+package com.twitter.algebird
+
+import org.scalatestplus.scalacheck.Checkers
+import org.scalatest.propspec.AnyPropSpec
+
+/**
+ * @author
+ *   Mansur Ashraf.
+ */
+trait CheckProperties extends AnyPropSpec with Checkers

algebird-test/src/test/scala-3/com/twitter/algebird/CheckProperties.scala

@@ -9,18 +9,18 @@ class AbstractAlgebraTest extends CheckProperties with Matchers {
 
   property("A Monoid should be able to sum") {
     val monoid = implicitly[Monoid[Int]]
-    forAll { intList: List[Int] => intList.sum == monoid.sum(intList) }
+    forAll((intList: List[Int]) => intList.sum == monoid.sum(intList))
   }
 
   property("A Ring should be able to product") {
     val ring = implicitly[Ring[Int]]
-    forAll { intList: List[Int] => intList.product == ring.product(intList) }
+    forAll((intList: List[Int]) => intList.product == ring.product(intList))
   }
 
   property("An OptionMonoid should be able to sum") {
     val monoid = implicitly[Monoid[Option[Int]]]
 
-    forAll { intList: List[Option[Int]] =>
+    forAll { (intList: List[Option[Int]]) =>
       val flattenedList = intList.flatten
       val expectedResult =
         if (flattenedList.nonEmpty) Some(flattenedList.sum) else None
@@ -31,7 +31,7 @@ class AbstractAlgebraTest extends CheckProperties with Matchers {
   property("An OptionMonoid based on a Semigroup should be able to sum") {
     val maxMonoid = implicitly[Monoid[Option[Max[Int]]]]
     val minMonoid = implicitly[Monoid[Option[Min[Int]]]]
-    forAll { intList: List[Option[Int]] =>
+    forAll { (intList: List[Option[Int]]) =>
       val minList = intList.map {
         case Some(x) => Some(Min(x))
         case None    => None
@@ -84,7 +84,7 @@ class AbstractAlgebraTest extends CheckProperties with Matchers {
 
   property("An ArrayMonoid should sum") {
     val monoid = new ArrayMonoid[Int]
-    forAll { intList: List[Int] =>
+    forAll { (intList: List[Int]) =>
       val (l, r) = intList.splitAt(intList.size / 2)
       val left = l.padTo(math.max(l.size, r.size), 0)
       val right = r.padTo(math.max(l.size, r.size), 0)
@@ -97,7 +97,7 @@ class AbstractAlgebraTest extends CheckProperties with Matchers {
 
   property("An ArrayGroup should negate") {
     val arrayGroup = new ArrayGroup[Int]
-    forAll { intList: List[Int] =>
+    forAll { (intList: List[Int]) =>
       intList.map(-1 * _).toSeq == arrayGroup
         .negate(intList.toArray)
         .toSeq
@@ -106,8 +106,12 @@ class AbstractAlgebraTest extends CheckProperties with Matchers {
 
   property("a user-defined product monoid should work") {
     case class Metrics(count: Int, largestValue: Option[Max[Int]])
-    implicit val MetricsMonoid = Monoid(Metrics.apply _, Metrics.unapply _)
-    implicit val metricsGen = Arbitrary {
+    val unapply: Metrics => Option[(Int, Option[Max[Int]])] = { case Metrics(count, largestValue) =>
+      Some((count, largestValue))
+    }
+    implicit val MetricsMonoid: Monoid[Metrics] =
+      Monoid.apply[Metrics, Int, Option[Max[Int]]](Metrics.apply _, unapply)
+    implicit val metricsGen: Arbitrary[Metrics] = Arbitrary[Metrics] {
       for {
         count <- Gen.choose(0, 10000)
         largest <- Gen.oneOf[Option[Max[Int]]](None, Gen.choose(1, 100).map(n => Some(Max(n))))

algebird-test/src/test/scala/com/twitter/algebird/AbstractAlgebraTest.scala

@@ -54,35 +54,35 @@ class ApplicativeProperties extends CheckProperties {
   property("sequenceGen") {
     // This follows from the laws, so we are just testing
     // the implementation of sequenceGen against sequence here
-    forAll { ls: List[Option[Int]] =>
+    forAll { (ls: List[Option[Int]]) =>
       val res: Option[Vector[Int]] = Applicative.sequenceGen(ls)
       Applicative.sequence(ls).map(_.toVector) == res
     }
   }
   // Applicative algebras:
   import BaseProperties._
   property("Applicative Semigroup") {
-    implicit val optSg = new ApplicativeSemigroup[Int, Option]
-    implicit val listSg = new ApplicativeSemigroup[String, List]
+    implicit val optSg: Semigroup[Option[Int]] = new ApplicativeSemigroup[Int, Option]
+    implicit val listSg: Semigroup[List[String]] = new ApplicativeSemigroup[String, List]
     // the + here is actually a cross-product, and testing sumOption blows up
     semigroupLaws[Option[Int]] && isAssociative[List[String]]
   }
 
   property("Applicative Monoid") {
-    implicit val optSg = new ApplicativeMonoid[Int, Option]
-    implicit val listSg = new ApplicativeMonoid[String, List]
+    implicit val optSg: Monoid[Option[Int]] = new ApplicativeMonoid[Int, Option]
+    implicit val listSg: Monoid[List[String]] = new ApplicativeMonoid[String, List]
     // the + here is actually a cross-product, and testing sumOption blows up
     monoidLaws[Option[Int]] && validZero[List[String]]
   }
 
   // These laws work for only "non-empty" monads
   property("Applicative Group") {
-    implicit val optSg = new ApplicativeGroup[Int, Some]
+    implicit val optSg: ApplicativeGroup[Int, Some] = new ApplicativeGroup[Int, Some]
     groupLaws[Some[Int]]
   }
 
   property("Applicative Ring") {
-    implicit val optSg = new ApplicativeRing[Int, Some]
+    implicit val optSg: ApplicativeRing[Int, Some] = new ApplicativeRing[Int, Some]
     ringLaws[Some[Int]]
   }
 }

algebird-test/src/test/scala/com/twitter/algebird/ApplicativeProperties.scala

@@ -26,7 +26,7 @@ class AveragedValueLaws extends CheckProperties {
   }
 
   property("AveragedValue.aggregator returns the average") {
-    forAll { v: NonEmptyVector[Double] => approxEq(1e-10)(avg(v.items), AveragedValue.aggregator(v.items)) }
+    forAll { (v: NonEmptyVector[Double]) => approxEq(1e-10)(avg(v.items), AveragedValue.aggregator(v.items)) }
   }
 
   property("AveragedValue instances subtract") {
@@ -42,7 +42,7 @@ class AveragedValueLaws extends CheckProperties {
   }
 
   property("AveragedValue works by + or sumOption") {
-    forAll { v: NonEmptyVector[Double] =>
+    forAll { (v: NonEmptyVector[Double]) =>
       val avgs = v.items.map(AveragedValue(_))
       val sumOpt = Semigroup.sumOption[AveragedValue](avgs).get
       val byPlus = avgs.reduce(_ + _)
@@ -53,7 +53,7 @@ class AveragedValueLaws extends CheckProperties {
   }
 
   def numericAggregatorTest[T: Numeric: Arbitrary]: Prop =
-    forAll { v: NonEmptyVector[T] =>
+    forAll { (v: NonEmptyVector[T]) =>
       val averaged = AveragedValue.numericAggregator[T].apply(v.items)
       approxEq(1e-10)(avg(v.items), averaged)
     }

algebird-test/src/test/scala/com/twitter/algebird/AveragedValueLaws.scala

@@ -250,13 +250,13 @@ class BloomFilterProperties extends ApproximateProperties("BloomFilter") {
 
   for (falsePositiveRate <- List(0.1, 0.01, 0.001)) {
     property(s"has small false positive rate with false positive rate = $falsePositiveRate") = {
-      implicit val intGen = Gen.choose(1, 1000)
+      implicit val intGen:Gen[Int] = Gen.choose(1, 1000)
       toProp(new BloomFilterFalsePositives[Int](falsePositiveRate), 50, 50, 0.01)
     }
   }
 
   property("approximate cardinality") = {
-    implicit val intGen = Gen.choose(1, 1000)
+    implicit val intGen:Gen[Int] = Gen.choose(1, 1000)
     toProp(new BloomFilterCardinality[Int], 50, 1, 0.01)
   }
 }