Add Gen.product and Gen.tailRecM

Author: oscar-stripe

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

@@ -323,13 +323,35 @@ 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("some") = forAll { n: Int =>
     forAll(some(n)) {
       case Some(m) if m == n => true
       case _ => false
     }
   }
 
+  property("tailRecM") = forAll { (init: Int) =>
+    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))
+      }
+
+    val g1 = Gen.tailRecM((10, init))(g)
+    def g2(x: (Int, Int)): Gen[Int] = g(x).flatMap {
+      case Left(y) => g2(y)
+      case Right(x) => Gen.const(x)
+    }
+
+    forAll(g1, g2((10, init)))(_ == _)
+  }
+
   property("uuid version 4") = forAll(uuid) { _.version == 4 }
 
   property("uuid unique") = forAll(uuid, uuid) {

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

@@ -467,6 +467,46 @@ object Gen extends GenArities{
     g.map(b.fromIterable)
   }
 
+  /** Monadic recursion on Gen
+   * This is a stack-safe loop that is the same as:
+   *
+   * {{{
+   *
+   * fn(a).flatMap {
+   *   case Left(a) => tailRec(a)(fn)
+   *   case Right(b) => Gen.const(b)
+   *   }
+   *
+   * }}}
+   *
+   * which is useful for doing monadic loops without blowing up the
+   * stack
+   */
+  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)
+      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)
+      }
+    }
+
+    gen[B] { (p: P, seed: Seed) =>
+      tailRecMR(a0, Set.empty) { a => 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)
+
   /** Wraps a generator lazily. The given parameter is only evaluated once,
    *  and not until the wrapper generator is evaluated. */
   def lzy[T](g: => Gen[T]): Gen[T] = {