improve tests and fix implementations

Author: oscar-stripe

jvm/src/test/scala/org/scalacheck/GenSpecification.scala

@@ -323,24 +323,34 @@ object GenSpecification extends Properties("Gen") {
     }
   }
 
-  property("product") = forAll { (a: Int, b: Int) =>
-    forAll(Gen.product(a, b)) {
-      case (a1, b1) => a1 == a && b1 == b
+  property("product") = forAll { (a: Int, b: Int, seeds: List[Seed]) =>
+    val ga = Gen.choose(Int.MinValue, a)
+    val gb = Gen.choose(Int.MinValue, b)
+
+    val prod1 = Gen.product(ga, gb)
+    val prod2 = ga.flatMap { a => gb.map((a, _)) }
+
+    val params = Gen.Parameters.default
+    seeds.forall { seed =>
+      prod1.pureApply(params, seed) == prod2.pureApply(params, seed)
     }
   }
 
   property("some") = forAll { n: Int =>
     forAll(some(n)) {
-      case Some(m) if m == n => true
+      case Some(m) => m == n
       case _ => false
     }
   }
 
-  property("tailRecM") = forAll { (init: Int) =>
+  property("tailRecM") = forAll { (init: Int, seeds: List[Seed]) =>
     val g: ((Int, Int)) => Gen[Either[(Int, Int), Int]] =
       {
-        case (c, x) if c <= 0 => Right(x)
-        case (c, x) => Left((c - 1, x * Int.MaxValue))
+        case (c, x) if c <= 0 =>
+          Gen.const(Right(x))
+        case (c, x) =>
+          val g = Gen.choose(Int.MinValue, x)
+          g.map { i => Left(((c - 1), i)) }
       }
 
     val g1 = Gen.tailRecM((10, init))(g)
@@ -349,7 +359,14 @@ object GenSpecification extends Properties("Gen") {
       case Right(x) => Gen.const(x)
     }
 
-    forAll(g1, g2((10, init)))(_ == _)
+    val finalG2 = g2((10, init))
+
+
+    val params = Gen.Parameters.default
+
+    seeds.forall { seed =>
+      g1.pureApply(params, seed) == finalG2.pureApply(params, seed)
+    }
   }
 
   property("uuid version 4") = forAll(uuid) { _.version == 4 }

src/main/scala/org/scalacheck/Gen.scala

@@ -484,28 +484,35 @@ object Gen extends GenArities{
    */
   def tailRecM[A, B](a0: A)(fn: A => Gen[Either[A, B]]): Gen[B] = {
     @tailrec
-    def tailRecMR[A, B](a: A, labs: Set[String])(fn: A => R[Either[A, B]]): R[B] = {
-      val re = fn(a)
+    def tailRecMR(a: A, seed: Seed, labs: Set[String])(fn: (A, Seed) => R[Either[A, B]]): R[B] = {
+      val re = fn(a, seed)
       val nextLabs = labs | re.labels
       re.retrieve match {
         case None => r(None, re.seed).copy(l = nextLabs)
         case Some(Right(b)) => r(Some(b), re.seed).copy(l = nextLabs)
-        case Some(Left(a)) => tailRecMR(a, nextLabs)(fn)
+        case Some(Left(a)) => tailRecMR(a, re.seed, nextLabs)(fn)
       }
     }
 
+    // This is the "Reader-style" appoach to making a stack-safe loop:
+    // we put one outer closure around an explicitly tailrec loop
     gen[B] { (p: P, seed: Seed) =>
-      tailRecMR(a0, Set.empty) { a => fn(a).doApply(p, seed) }
+      tailRecMR(a0, seed, Set.empty) { (a, seed) => fn(a).doApply(p, seed) }
     }
   }
 
   /** Build a pair from two generators
    */
   def product[A, B](ga: Gen[A], gb: Gen[B]): Gen[(A, B)] =
-    for {
-      a <- ga
-      b <- gb
-    } yield (a, b)
+    gen[(A, B)] { (p: P, seed: Seed) =>
+      val ra = ga.doApply(p, seed)
+      ra.retrieve match {
+        case None => r(None, ra.seed).copy(l = ra.labels)
+        case Some(a) =>
+          val rb = gb.doApply(p, ra.seed)
+          rb.map((a, _)).copy(l = ra.labels | rb.labels)
+      }
+    }
 
   /** Wraps a generator lazily. The given parameter is only evaluated once,
    *  and not until the wrapper generator is evaluated. */