From beee1d66dd46762f2806debfdb28c370598d0e53 Mon Sep 17 00:00:00 2001
From: Patrick Oscar Boykin <boykin@pobox.com>
Date: Mon, 21 Feb 2022 09:35:44 -1000
Subject: [PATCH] Improve String generation

---
 .../src/main/scala/cats/parse/Numbers.scala   |   4 +-
 .../test/scala/cats/parse/ParserTest.scala    | 426 +++++++++---------
 2 files changed, 212 insertions(+), 218 deletions(-)

diff --git a/core/shared/src/main/scala/cats/parse/Numbers.scala b/core/shared/src/main/scala/cats/parse/Numbers.scala
index af5e196d..09239b75 100644
--- a/core/shared/src/main/scala/cats/parse/Numbers.scala
+++ b/core/shared/src/main/scala/cats/parse/Numbers.scala
@@ -30,11 +30,11 @@ object Numbers {
 
   /** zero or more digit chars
     */
-  val digits0: Parser0[String] = digit.rep0.string
+  val digits0: Parser0[String] = digit.repAs0
 
   /** one or more digit chars
     */
-  val digits: Parser[String] = digit.rep.string
+  val digits: Parser[String] = digit.repAs
 
   /** a single base 10 digit excluding 0
     */
diff --git a/core/shared/src/test/scala/cats/parse/ParserTest.scala b/core/shared/src/test/scala/cats/parse/ParserTest.scala
index c993b8b8..fe63f0e2 100644
--- a/core/shared/src/test/scala/cats/parse/ParserTest.scala
+++ b/core/shared/src/test/scala/cats/parse/ParserTest.scala
@@ -65,6 +65,16 @@ object GenT {
 }
 
 object ParserGen {
+  // a small space to increase the chance a random parser matches
+  val genSmallChar: Gen[Char] = Gen.oneOf('A', 'a', 'B', 'b', ' ')
+  val genSmallString: Gen[String] =
+    Gen.geometric(5.0).flatMap(Gen.stringOfN(_, genSmallChar))
+
+  val genString: Gen[String] =
+    Gen.oneOf(genSmallString, Gen.asciiPrintableStr, Arbitrary.arbString.arbitrary)
+
+  implicit val arbString: Arbitrary[String] = Arbitrary(genString)
+
   implicit val functorGen: Functor[Gen] =
     new Functor[Gen] {
       def map[A, B](ga: Gen[A])(fn: A => B) = ga.map(fn)
@@ -82,12 +92,12 @@ object ParserGen {
     Gen.oneOf(arbGen[Int], arbGen[Boolean], arbGen[String], arbGen[(Int, Int)])
 
   val expect0: Gen[GenT[Parser0]] =
-    Arbitrary.arbitrary[String].map { str =>
+    genString.map { str =>
       GenT(Parser.string0(str))
     }
 
   val ignoreCase0: Gen[GenT[Parser0]] =
-    Arbitrary.arbitrary[String].map { str =>
+    genString.map { str =>
       GenT(Parser.ignoreCase0(str))
     }
 
@@ -129,13 +139,13 @@ object ParserGen {
     }
 
   val expect1: Gen[GenT[Parser]] =
-    Arbitrary.arbitrary[String].map { str =>
+    genString.map { str =>
       if (str.isEmpty) GenT(Parser.fail: Parser[Unit])
       else GenT(Parser.string(str))
     }
 
   val ignoreCase: Gen[GenT[Parser]] =
-    Arbitrary.arbitrary[String].map { str =>
+    genString.map { str =>
       if (str.isEmpty) GenT(Parser.fail: Parser[Unit])
       else GenT(Parser.ignoreCase(str))
     }
@@ -144,7 +154,7 @@ object ParserGen {
     Gen.const(GenT(Parser.fail: Parser0[Unit]))
 
   val failWith: Gen[GenT[Parser0]] =
-    Arbitrary.arbitrary[String].map { str =>
+    genString.map { str =>
       GenT(Parser.failWith[Unit](str))
     }
 
@@ -183,12 +193,12 @@ object ParserGen {
   }
 
   def withContext0(g: GenT[Parser0]): Gen[GenT[Parser0]] =
-    Arbitrary.arbitrary[String].map { ctx =>
+    genString.map { ctx =>
       GenT(Parser.withContext0(g.fa, ctx))(g.cogen)
     }
 
   def withContext(g: GenT[Parser]): Gen[GenT[Parser]] =
-    Arbitrary.arbitrary[String].map { ctx =>
+    genString.map { ctx =>
       GenT(Parser.withContext(g.fa, ctx))(g.cogen)
     }
 
@@ -598,7 +608,7 @@ object ParserGen {
 
 class ParserTest extends munit.ScalaCheckSuite {
 
-  import ParserGen.{arbParser0, arbParser, biasSmall}
+  import ParserGen.{arbParser0, arbParser, biasSmall, genString, arbString}
 
   val tests: Int = if (BitSetUtil.isScalaJs) 50 else 2000
 
@@ -694,7 +704,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("Parser0 on success replaces parsed value") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val res0 = genP.fa.as("something").parse(str)
       res0 match {
         case Left(_) => ()
@@ -768,7 +778,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("voided only changes the result") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       def go[A](p: Parser0[A]) =
         p.parse(str).leftMap(_.offsets)
 
@@ -784,7 +794,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("voided only changes the result Parser") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       def go[A](p: Parser0[A]) =
         p.parse(str).leftMap(_.offsets)
 
@@ -802,7 +812,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("expected in errors gives valid offsets") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       genP.fa.parse(str) match {
         case Left(err) =>
           err.offsets.forall { off =>
@@ -815,7 +825,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf0 nesting doesn't change results") {
-    forAll(Gen.listOf(ParserGen.gen0), Gen.listOf(ParserGen.gen0), Arbitrary.arbitrary[String]) {
+    forAll(Gen.listOf(ParserGen.gen0), Gen.listOf(ParserGen.gen0), genString) {
       (genP1, genP2, str) =>
         val oneOf = Parser.oneOf0((genP1 ::: genP2).map(_.fa))
         val oneOf2 = Parser.oneOf0(genP1.map(_.fa)).orElse(Parser.oneOf0(genP2.map(_.fa)))
@@ -825,16 +835,15 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf nesting doesn't change results") {
-    forAll(Gen.listOf(ParserGen.gen), Gen.listOf(ParserGen.gen), Arbitrary.arbitrary[String]) {
-      (genP1, genP2, str) =>
-        val oneOf = Parser.oneOf((genP1 ::: genP2).map(_.fa))
-        val oneOf2 = Parser
-          .oneOf(genP1.map(_.fa))
-          .orElse(
-            Parser.oneOf(genP2.map(_.fa))
-          )
+    forAll(Gen.listOf(ParserGen.gen), Gen.listOf(ParserGen.gen), genString) { (genP1, genP2, str) =>
+      val oneOf = Parser.oneOf((genP1 ::: genP2).map(_.fa))
+      val oneOf2 = Parser
+        .oneOf(genP1.map(_.fa))
+        .orElse(
+          Parser.oneOf(genP2.map(_.fa))
+        )
 
-        assertEquals(oneOf.parse(str).leftMap(_.offsets), oneOf2.parse(str).leftMap(_.offsets))
+      assertEquals(oneOf.parse(str).leftMap(_.offsets), oneOf2.parse(str).leftMap(_.offsets))
     }
   }
 
@@ -869,13 +878,13 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf0 composes as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP1, genP2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP2, str) =>
       oneOfLaw(genP1.fa, genP2.fa, str)
     }
   }
 
   property("oneOf composes as expected") {
-    forAll(ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) { (genP1, genP2, str) =>
+    forAll(ParserGen.gen, ParserGen.gen, genString) { (genP1, genP2, str) =>
       oneOfLaw(genP1.fa, genP2.fa, str)
     }
   }
@@ -904,7 +913,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf0 same as foldLeft(fail)(_.orElse(_))") {
-    forAll(Gen.listOf(ParserGen.gen0), Arbitrary.arbitrary[String]) { (genP1, str) =>
+    forAll(Gen.listOf(ParserGen.gen0), genString) { (genP1, str) =>
       val oneOfImpl = genP1.foldLeft(Parser.fail: Parser0[Any]) { (leftp, p) =>
         leftp.orElse(p.fa)
       }
@@ -917,7 +926,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf same as foldLeft(fail)(_.orElse(_))") {
-    forAll(Gen.listOf(ParserGen.gen), Arbitrary.arbitrary[String]) { (genP1, str) =>
+    forAll(Gen.listOf(ParserGen.gen), genString) { (genP1, str) =>
       val oneOfImpl = genP1.foldLeft(Parser.fail[Any]) { (leftp, p) => leftp.orElse(p.fa) }
 
       assertEquals(
@@ -928,7 +937,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("string can be recovered with index") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val r1 = genP.fa.string.parse(str)
       val r2 = (genP.fa ~ Parser.index).map { case (_, end) => str.substring(0, end) }.parse(str)
 
@@ -937,7 +946,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("backtrack orElse pure always succeeds") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val p1 = genP.fa.backtrack.orElse(Parser.pure(())): Parser0[Any]
 
       assert(p1.parse(str).isRight)
@@ -945,7 +954,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("backtrack.? pure always succeeds") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val p1 = genP.fa.backtrack.?
 
       assert(p1.parse(str).isRight)
@@ -953,7 +962,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.backtrack either succeeds or fails at 0") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       a.fa.backtrack.parse(str) match {
         case Right(_) => ()
         case Left(err) => assertEquals(err.failedAtOffset, 0)
@@ -962,7 +971,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a ~ b composes as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (p1, p2, str) =>
       val composed = p1.fa ~ p2.fa
       val cres = composed.parse(str)
 
@@ -986,7 +995,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a ~ b composes as expected parser1") {
-    forAll(ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen, ParserGen.gen, genString) { (p1, p2, str) =>
       val composed = p1.fa ~ p2.fa
       val cres = composed.parse(str)
 
@@ -1011,7 +1020,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.with1 ~ b composes as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen, genString) { (p1, p2, str) =>
       val composed = p1.fa.with1 ~ p2.fa
       val cres = composed.parse(str)
 
@@ -1032,7 +1041,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.soft ~ b composes as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (p1, p2, str) =>
       val composed = p1.fa.soft ~ p2.fa
       val cres = composed.parse(str)
 
@@ -1056,7 +1065,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a1.soft ~ b composes as expected Parser") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p1, p2, str) =>
       val composed = p1.fa.soft ~ p2.fa
       val cres = composed.parse(str)
 
@@ -1080,7 +1089,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.with1.soft ~ b1 composes as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen, genString) { (p1, p2, str) =>
       val composed = p1.fa.with1.soft ~ p2.fa
       val cres = composed.parse(str)
 
@@ -1104,7 +1113,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.flatMap(b) composes as expected parser00") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, str) =>
+    forAll(ParserGen.gen0, genString) { (p1, str) =>
       forAll(Gen.function1(ParserGen.gen0)(p1.cogen)) { fn =>
         val flatMapped = p1.fa.flatMap { a => fn(a).fa }
 
@@ -1125,7 +1134,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.flatMap(b) composes as expected parser10") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, str) =>
+    forAll(ParserGen.gen, genString) { (p1, str) =>
       forAll(Gen.function1(ParserGen.gen0)(p1.cogen)) { fn =>
         val flatMapped = p1.fa.flatMap { a => fn(a).fa }
 
@@ -1148,7 +1157,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.flatMap(b) composes as expected parser01") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, str) =>
+    forAll(ParserGen.gen0, genString) { (p1, str) =>
       forAll(Gen.function1(ParserGen.gen)(p1.cogen)) { fn =>
         val flatMapped = p1.fa.with1.flatMap { a => fn(a).fa }
 
@@ -1265,7 +1274,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("rep0 can be reimplemented with oneOf0 and defer") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       def rep0[A](pa: Parser[A]): Parser0[List[A]] =
         Parser
           .recursive[List[A]] { tail =>
@@ -1285,7 +1294,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("rep0 is consistent with rep") {
-    forAll(ParserGen.gen, biasSmall(1), Arbitrary.arbitrary[String]) { (genP, min, str) =>
+    forAll(ParserGen.gen, biasSmall(1), genString) { (genP, min, str) =>
       val repA = genP.fa.rep0(min)
       val repB = genP.fa
         .rep(min)
@@ -1296,7 +1305,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("repExactlyAs is consistent with repAs") {
-    forAll(ParserGen.gen, Gen.choose(1, 10000), Arbitrary.arbitrary[String]) { (genP, n, str) =>
+    forAll(ParserGen.gen, Gen.choose(1, 10000), genString) { (genP, n, str) =>
       val repA = genP.fa.repAs[NonEmptyVector[_]](n, n)
       val repB = genP.fa.repExactlyAs[NonEmptyVector[_]](n)
       assertEquals(repA.parse(str), repB.parse(str))
@@ -1308,7 +1317,7 @@ class ParserTest extends munit.ScalaCheckSuite {
       min <- Gen.choose(1, Int.MaxValue)
       max <- Gen.choose(min, Int.MaxValue)
     } yield (min, max)
-    forAll(ParserGen.gen, validMinMax, Arbitrary.arbitrary[String]) { (genP, minmax, str) =>
+    forAll(ParserGen.gen, validMinMax, genString) { (genP, minmax, str) =>
       {
         val (min, max) = minmax
         genP.fa.rep(min, max).parse(str).foreach { case (_, l) =>
@@ -1325,7 +1334,7 @@ class ParserTest extends munit.ScalaCheckSuite {
       max <- biasSmall(min)
     } yield (min, max)
 
-    forAll(ParserGen.gen, validMinMax, Arbitrary.arbitrary[String]) { (genP, minmax, str) =>
+    forAll(ParserGen.gen, validMinMax, genString) { (genP, minmax, str) =>
       {
         val (min, max) = minmax
         genP.fa.rep0(min, max).parse(str).foreach { case (_, l) =>
@@ -1337,7 +1346,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("rep0 parses at most max entries (min == 0)") {
-    forAll(ParserGen.gen, biasSmall(0), Arbitrary.arbitrary[String]) { (genP, max, str) =>
+    forAll(ParserGen.gen, biasSmall(0), genString) { (genP, max, str) =>
       genP.fa.rep0(0, max).parse(str).foreach { case (_, l) => assert(l.length <= max) }
     }
   }
@@ -1423,7 +1432,7 @@ class ParserTest extends munit.ScalaCheckSuite {
         max <- biasSmall(Integer.max(min, 1))
       } yield MinMax(min, max)
 
-    forAll(ParserGen.gen, biasSmall(0), Arbitrary.arbitrary[String]) { (genP, min0, str) =>
+    forAll(ParserGen.gen, biasSmall(0), genString) { (genP, min0, str) =>
       val min = min0 & Int.MaxValue // make sure it is positive
       // repSep0 internally uses | which triggers rewriting optimizations
       val p1a = genP.fa.repSep0(min = min, sep = Parser.unit)
@@ -1437,24 +1446,23 @@ class ParserTest extends munit.ScalaCheckSuite {
 
       assertEquals(p2a.parse(str).leftMap(_.offsets), p2b.parse(str).leftMap(_.offsets))
     } &&
-    forAll(ParserGen.gen, minMax, Arbitrary.arbitrary[String]) {
-      case (genP, MinMax(min, max), str) =>
-        // repSep0 internally uses | which triggers rewriting optimizations
-        val p1a = genP.fa.repSep0(min = min, max = max, sep = Parser.unit)
-        val p1b = genP.fa.rep0(min = min, max = max)
+    forAll(ParserGen.gen, minMax, genString) { case (genP, MinMax(min, max), str) =>
+      // repSep0 internally uses | which triggers rewriting optimizations
+      val p1a = genP.fa.repSep0(min = min, max = max, sep = Parser.unit)
+      val p1b = genP.fa.rep0(min = min, max = max)
 
-        assertEquals(p1a.parse(str).leftMap(_.offsets), p1b.parse(str).leftMap(_.offsets))
+      assertEquals(p1a.parse(str).leftMap(_.offsets), p1b.parse(str).leftMap(_.offsets))
 
-        val min1 = if (min < 1) 1 else min
-        val p2a = genP.fa.repSep(min = min1, max = max, sep = Parser.unit)
-        val p2b = genP.fa.rep(min = min1, max = max)
+      val min1 = if (min < 1) 1 else min
+      val p2a = genP.fa.repSep(min = min1, max = max, sep = Parser.unit)
+      val p2b = genP.fa.rep(min = min1, max = max)
 
-        assertEquals(p2a.parse(str).leftMap(_.offsets), p2b.parse(str).leftMap(_.offsets))
+      assertEquals(p2a.parse(str).leftMap(_.offsets), p2b.parse(str).leftMap(_.offsets))
     }
   }
 
   property("repSep without min is the same as repSep with min = 1") {
-    forAll(ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, genPSep, str) =>
+    forAll(ParserGen.gen, ParserGen.gen, genString) { (genP, genPSep, str) =>
       {
         val p = genP.fa
         val psep = genPSep.fa
@@ -1464,7 +1472,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("repSep with sep = fail is the same as parsing 1") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       assertEquals(
         genP.fa.parse(str),
         Parser.repSep(genP.fa, Parser.fail).parse(str).map { case (rest, nel) =>
@@ -1477,7 +1485,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   property("charsWhile/charsWhere consistency") {
     forAll(
       Gen.choose(0, 100).flatMap(Gen.listOfN(_, Gen.choose(Char.MinValue, Char.MaxValue))),
-      Arbitrary.arbitrary[String]
+      genString
     ) { (chars, str) =>
       val pred = chars.toSet
       val p1a = Parser.charsWhile0(pred)
@@ -1504,7 +1512,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p orElse p == p") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       val res0 = genP.fa.parse(str)
       val res1 = genP.fa.orElse(genP.fa).parse(str)
       assertEquals(res1, res0)
@@ -1512,7 +1520,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p orElse p == p (0)") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val res0 = genP.fa.parse(str)
       val res1 = genP.fa.orElse(genP.fa).parse(str)
       assertEquals(res1, res0)
@@ -1520,7 +1528,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("Parser fails or consumes 1 or more") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       val res0 = genP.fa.parse(str)
       res0 match {
         case Left(_) => assert(true)
@@ -1530,7 +1538,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p1.backtrack.orElse(p2) succeeds if either p1 or p2 do (Parser0)") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (p1, p2, str) =>
       val ores = p1.fa.backtrack.orElse(p2.fa).parse(str)
       val r1 = p1.fa.parse(str)
       val r = if (r1.isLeft) p2.fa.parse(str) else r1
@@ -1542,7 +1550,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p1.backtrack.orElse(p2) succeeds if either p1 or p2 do") {
-    forAll(ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen, ParserGen.gen, genString) { (p1, p2, str) =>
       val ores = p1.fa.backtrack.orElse(p2.fa).parse(str)
       val r1 = p1.fa.parse(str)
       val r = if (r1.isLeft) p2.fa.parse(str) else r1
@@ -1581,7 +1589,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("with1 *> and with1 <* work as expected") {
-    forAll(ParserGen.gen0, ParserGen.gen, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen, genString) { (p1, p2, str) =>
       val rp1 = p1.fa.with1 *> p2.fa
       val rp2 = (p1.fa.void.with1 ~ p2.fa).map(_._2)
       assertEquals(rp1.parse(str), rp2.parse(str))
@@ -1593,7 +1601,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a1 *> b and a1 <* b") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, p2, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p1, p2, str) =>
       assertEquals(
         (p1.fa *> p2.fa).parse(str),
         Parser.product10(p1.fa.void, p2.fa).map(_._2).parse(str)
@@ -1606,17 +1614,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse between open and close") {
-    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.between(genP.fa, genQ.fa)
-        val pb = genP.fa *> genP1.fa <* genQ.fa
+    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.between(genP.fa, genQ.fa)
+      val pb = genP.fa *> genP1.fa <* genQ.fa
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("surroundedBy consistent with between") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.between(genP.fa, genP.fa)
       val pb = genP1.fa.surroundedBy(genP.fa)
 
@@ -1625,17 +1632,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse between open and close with Parser this") {
-    forAll(ParserGen.gen, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.between(genP.fa, genQ.fa)
-        val pb = genP.fa *> genP1.fa <* genQ.fa
+    forAll(ParserGen.gen, ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.between(genP.fa, genQ.fa)
+      val pb = genP.fa *> genP1.fa <* genQ.fa
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("surroundedBy consistent with between with Parser this") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.between(genP.fa, genP.fa)
       val pb = genP1.fa.surroundedBy(genP.fa)
 
@@ -1644,17 +1650,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse soft.between open and close") {
-    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.soft.between(genP.fa, genQ.fa)
-        val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
+    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.soft.between(genP.fa, genQ.fa)
+      val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("soft.surroundedBy consistent with soft.between") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.soft.between(genP.fa, genP.fa)
       val pb = genP1.fa.soft.surroundedBy(genP.fa)
 
@@ -1663,17 +1668,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse soft.between open and close with Parser this") {
-    forAll(ParserGen.gen, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.soft.between(genP.fa, genQ.fa)
-        val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
+    forAll(ParserGen.gen, ParserGen.gen0, ParserGen.gen0, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.soft.between(genP.fa, genQ.fa)
+      val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("soft.surroundedBy consistent with between with Parser this") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.soft.between(genP.fa, genP.fa)
       val pb = genP1.fa.soft.surroundedBy(genP.fa)
 
@@ -1682,17 +1686,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse with1.between open and close with Parser args") {
-    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.with1.between(genP.fa, genQ.fa)
-        val pb = genP.fa *> genP1.fa <* genQ.fa
+    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.with1.between(genP.fa, genQ.fa)
+      val pb = genP.fa *> genP1.fa <* genQ.fa
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("with1.surroundedBy consistent with between with Parser this") {
-    forAll(ParserGen.gen0, ParserGen.gen, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.with1.between(genP.fa, genP.fa)
       val pb = genP1.fa.with1.surroundedBy(genP.fa)
 
@@ -1701,17 +1704,16 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parse soft.with1.between open and close with Parser args") {
-    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) {
-      (genP1, genP, genQ, str) =>
-        val pa = genP1.fa.soft.with1.between(genP.fa, genQ.fa)
-        val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
+    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, genString) { (genP1, genP, genQ, str) =>
+      val pa = genP1.fa.soft.with1.between(genP.fa, genQ.fa)
+      val pb = genP.fa.soft *> (genP1.fa.soft <* genQ.fa)
 
-        assertEquals(pa.parse(str), pb.parse(str))
+      assertEquals(pa.parse(str), pb.parse(str))
     }
   }
 
   property("soft.with1.surroundedBy consistent with between with Parser this") {
-    forAll(ParserGen.gen0, ParserGen.gen, Arbitrary.arbitrary[String]) { (genP1, genP, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen, genString) { (genP1, genP, str) =>
       val pa = genP1.fa.soft.with1.between(genP.fa, genP.fa)
       val pb = genP1.fa.soft.with1.surroundedBy(genP.fa)
 
@@ -1720,7 +1722,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("exactly one of x or !x parse") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (p1, str) =>
+    forAll(ParserGen.gen0, genString) { (p1, str) =>
       val notx = !p1.fa
 
       val xor = p1.fa.parse(str).isRight ^ notx.parse(str).isRight
@@ -1729,7 +1731,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("if x ~ y matches then x ~ y.peek match") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (x, y, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (x, y, str) =>
       val m1 = (x.fa ~ y.fa).parse(str)
       val m2 = ((x.fa ~ y.fa.peek).map(_._1)).parse(str)
 
@@ -1741,7 +1743,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("if x matches then x.peek matches but returns the whole string and unit") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (x, str) =>
+    forAll(ParserGen.gen0, genString) { (x, str) =>
       if (x.fa.parse(str).isRight) {
         assertEquals(x.fa.peek.parse(str), Right((str, ())))
       }
@@ -1749,7 +1751,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("(a.soft ~ b) == a ~ b in success of expected (not partials)") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, str) =>
       val left = a.fa.soft ~ b.fa
       val right = a.fa ~ b.fa
       val leftRes = left.parse(str).leftMap(_.expected)
@@ -1759,7 +1761,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("(a.soft ~ b) == softProduct(a, b)") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, str) =>
       val left = a.fa.soft ~ b.fa
       val right = Parser.softProduct0(a.fa, b.fa)
       assertEquals(left.parse(str), right.parse(str))
@@ -1775,7 +1777,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("(a1.soft ~ b) == softProduct(a, b)") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (a, b, str) =>
       val left1 = a.fa.soft ~ b.fa
       val right1 = Parser.softProduct10(a.fa, b.fa)
       assertEquals(left1.parse(str), right1.parse(str))
@@ -1800,7 +1802,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("Parser.until is like a search") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val p = Parser.until0(a.fa) *> a.fa
       def loopMatch(cnt: Int): Option[(String, a.A)] =
         (Parser.length0(cnt) *> a.fa).parse(str) match {
@@ -1814,7 +1816,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("Parser.repUntil end Parser succeeds works as expected") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p, end, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p, end, str) =>
       val left = Parser.repUntil(p.fa.string, end.fa).parse(str)
       val right = (Parser.not(end.fa).void.with1 ~ p.fa.string).rep.map(_.map(_._2)).parse(str)
 
@@ -1830,7 +1832,7 @@ class ParserTest extends munit.ScalaCheckSuite {
         case Left(_) => ()
       }
     } &&
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p, end, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p, end, str) =>
       val left = Parser.repUntil0(p.fa.string, end.fa).parse(str)
       val right = (Parser.not(end.fa).void.with1 ~ p.fa.string).rep0.map(_.map(_._2)).parse(str)
 
@@ -1849,7 +1851,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.repUntilAs(end) matches a.repUntil(end)") {
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p, end, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p, end, str) =>
       val left = p.fa.string.repUntilAs[NonEmptyList[String]](end.fa).parse(str)
       val right = p.fa.string.repUntil(end.fa).parse(str)
 
@@ -1865,7 +1867,7 @@ class ParserTest extends munit.ScalaCheckSuite {
         case Left(_) => ()
       }
     } &&
-    forAll(ParserGen.gen, ParserGen.gen0, Arbitrary.arbitrary[String]) { (p, end, str) =>
+    forAll(ParserGen.gen, ParserGen.gen0, genString) { (p, end, str) =>
       val left = p.fa.string.repUntilAs0[List[String]](end.fa).parse(str)
       val right = p.fa.string.repUntil0(end.fa).parse(str)
 
@@ -1884,7 +1886,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("parseAll law") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pall = (a.fa <* Parser.end).parse(str).map(_._2)
 
       assertEquals(a.fa.parseAll(str), pall)
@@ -1904,73 +1906,69 @@ class ParserTest extends munit.ScalaCheckSuite {
    * Instead, we have some weakened versions of distributive laws
    */
   property("b.orElse(c) ~ a == (b ~ a).orElse((!b) *> (c ~ a))") {
-    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (a, b, c, str) =>
-        val pa = a.fa
-        val pb = b.fa
-        val pc = c.fa
+    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, genString) { (a, b, c, str) =>
+      val pa = a.fa
+      val pb = b.fa
+      val pc = c.fa
 
-        val left = pb.orElse(pc) ~ pa
-        val right = (pb ~ pa).orElse((!pb) *> (pc ~ pa))
+      val left = pb.orElse(pc) ~ pa
+      val right = (pb ~ pa).orElse((!pb) *> (pc ~ pa))
 
-        val leftRes = left.parse(str).toOption
-        val rightRes = right.parse(str).toOption
-        assertEquals(leftRes, rightRes)
+      val leftRes = left.parse(str).toOption
+      val rightRes = right.parse(str).toOption
+      assertEquals(leftRes, rightRes)
     }
   }
 
   property("b.orElse(c) ~ a == (b ~ a).orElse((!b) *> (c ~ a))") {
-    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) {
-      (a, b, c, str) =>
-        val pa = a.fa
-        val pb = b.fa
-        val pc = c.fa
-
-        val left = pb.orElse(pc) ~ pa
-        val right = (pb ~ pa).orElse((!pb).with1 *> (pc ~ pa))
-
-        val leftRes = left.parseAll(str).toOption
-        val rightRes = right.parseAll(str).toOption
-        if (leftRes.isDefined && rightRes.isDefined) {
-          assertEquals(leftRes, rightRes)
-        } else ()
+    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, genString) { (a, b, c, str) =>
+      val pa = a.fa
+      val pb = b.fa
+      val pc = c.fa
+
+      val left = pb.orElse(pc) ~ pa
+      val right = (pb ~ pa).orElse((!pb).with1 *> (pc ~ pa))
+
+      val leftRes = left.parseAll(str).toOption
+      val rightRes = right.parseAll(str).toOption
+      if (leftRes.isDefined && rightRes.isDefined) {
+        assertEquals(leftRes, rightRes)
+      } else ()
     }
   }
 
   property("a ~ b.orElse(c) == (a.soft ~ b).orElse(a ~ c)") {
-    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) {
-      (a, b, c, str) =>
-        val pa = a.fa
-        val pb = b.fa
-        val pc = c.fa
+    forAll(ParserGen.gen0, ParserGen.gen0, ParserGen.gen0, genString) { (a, b, c, str) =>
+      val pa = a.fa
+      val pb = b.fa
+      val pc = c.fa
 
-        val left = pa ~ pb.orElse(pc)
-        val right = (pa.soft ~ pb).orElse(pa ~ pc)
+      val left = pa ~ pb.orElse(pc)
+      val right = (pa.soft ~ pb).orElse(pa ~ pc)
 
-        val leftRes = left.parse(str).toOption
-        val rightRes = right.parse(str).toOption
-        assertEquals(leftRes, rightRes)
+      val leftRes = left.parse(str).toOption
+      val rightRes = right.parse(str).toOption
+      assertEquals(leftRes, rightRes)
     }
   }
 
   property("a ~ b.orElse(c) == (a.soft ~ b).orElse(a ~ c)") {
-    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) {
-      (a, b, c, str) =>
-        val pa = a.fa
-        val pb = b.fa
-        val pc = c.fa
+    forAll(ParserGen.gen0, ParserGen.gen, ParserGen.gen, genString) { (a, b, c, str) =>
+      val pa = a.fa
+      val pb = b.fa
+      val pc = c.fa
 
-        val left = pa ~ pb.orElse(pc)
-        val right = (pa.soft.with1 ~ pb).orElse(pa.with1 ~ pc)
+      val left = pa ~ pb.orElse(pc)
+      val right = (pa.soft.with1 ~ pb).orElse(pa.with1 ~ pc)
 
-        val leftRes = left.parse(str).toOption
-        val rightRes = right.parse(str).toOption
-        assertEquals(leftRes, rightRes)
+      val leftRes = left.parse(str).toOption
+      val rightRes = right.parse(str).toOption
+      assertEquals(leftRes, rightRes)
     }
   }
 
   property("a.backtrack.orElse(b) parses iff b.backtrack.orElse(a) (Parser0)") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, str) =>
       val pa = a.fa
       val pb = b.fa
 
@@ -1984,7 +1982,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.backtrack.orElse(b) parses iff b.backtrack.orElse(a)") {
-    forAll(ParserGen.gen, ParserGen.gen, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen, ParserGen.gen, genString) { (a, b, str) =>
       val pa = a.fa
       val pb = b.fa
 
@@ -2013,7 +2011,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.repAs0[Vector[A]] matches a.rep0.map(_.toVector)") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen, genString) { (a, str) =>
       val pa: Parser[a.A] = a.fa
 
       val left = pa.repAs0[Vector[a.A]]
@@ -2026,7 +2024,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.repAs[Vector[A]] matches a.rep.map(_.toList.toVector)") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen, genString) { (a, str) =>
       val pa: Parser[a.A] = a.fa
 
       val left = pa.repAs0[Vector[a.A]]
@@ -2039,7 +2037,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.string.repAs0[String] matches a.string.rep0.map(_.mkString)") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen, genString) { (a, str) =>
       val pa: Parser[String] = a.fa.string
 
       val left = pa.repAs0[String]
@@ -2052,7 +2050,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.repAs0[Unit] matches a.rep0.void") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen, genString) { (a, str) =>
       val pa: Parser[a.A] = a.fa
 
       val left = pa.repAs0[Unit](Accumulator0.unitAccumulator0)
@@ -2065,7 +2063,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.peek == a.peek.peek") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pa = a.fa
 
       val left = pa.peek
@@ -2078,7 +2076,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.backtrack.peek.orElse(b.peek) == (a.backtrack.orElse(b)).peek") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, str) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, str) =>
       val pa = a.fa.backtrack
       val pb = b.fa
 
@@ -2092,7 +2090,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.peek == a.peek *> a.peek") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pa = a.fa.peek
 
       val left = pa
@@ -2105,7 +2103,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("!a == (!a) *> (!a)") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pa = !a.fa
 
       val left = pa
@@ -2118,7 +2116,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("!(!a) == a.peek") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pa = a.fa
 
       val left = (!(!pa))
@@ -2131,7 +2129,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("!(!(!a)) == !a") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, str) =>
+    forAll(ParserGen.gen0, genString) { (a, str) =>
       val pa = a.fa
 
       val left = !(!(!pa))
@@ -2242,7 +2240,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p.filter(_ => true) == p") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val res0 = genP.fa.filter(_ => true).parse(str)
       val res1 = genP.fa.parse(str)
       assertEquals(res0, res1)
@@ -2250,14 +2248,14 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("p.filter(_ => false) fails") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen0, genString) { (genP, str) =>
       val res = genP.fa.filter(_ => false).parse(str)
       assert(res.isLeft)
     }
   }
 
   property("a Parser never succeeds and does not advance") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (genP, str) =>
+    forAll(ParserGen.gen, genString) { (genP, str) =>
       genP.fa.parse(str) match {
         case Right((rest, _)) => assertNotEquals(rest, str)
         case Left(_) => ()
@@ -2490,7 +2488,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.string ~ b.string == (a ~ b).string") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, toParse) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, toParse) =>
       val pa = a.fa
       val pb = b.fa
 
@@ -2502,7 +2500,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a.string.soft ~ b.string == (a.soft ~ b).string") {
-    forAll(ParserGen.gen0, ParserGen.gen0, Arbitrary.arbitrary[String]) { (a, b, toParse) =>
+    forAll(ParserGen.gen0, ParserGen.gen0, genString) { (a, b, toParse) =>
       val pa = a.fa
       val pb = b.fa
 
@@ -2514,28 +2512,26 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("oneOf0(a.map(_.string)) ~ oneOf0(a).string") {
-    forAll(Gen.choose(0, 5).flatMap(Gen.listOfN(_, ParserGen.gen0)), Arbitrary.arbitrary[String]) {
-      (as, toParse) =>
-        val left = Parser.oneOf0(as.map(_.fa.string))
-        val right = Parser.oneOf0[Any](as.map(_.fa)).string
+    forAll(Gen.choose(0, 5).flatMap(Gen.listOfN(_, ParserGen.gen0)), genString) { (as, toParse) =>
+      val left = Parser.oneOf0(as.map(_.fa.string))
+      val right = Parser.oneOf0[Any](as.map(_.fa)).string
 
-        assertEquals(
-          left.parse(toParse).leftMap(_.offsets),
-          right.parse(toParse).leftMap(_.offsets)
-        )
+      assertEquals(
+        left.parse(toParse).leftMap(_.offsets),
+        right.parse(toParse).leftMap(_.offsets)
+      )
     }
   }
 
   property("oneOf(a.map(_.string)) ~ oneOf(a).string") {
-    forAll(Gen.choose(0, 5).flatMap(Gen.listOfN(_, ParserGen.gen)), Arbitrary.arbitrary[String]) {
-      (as, toParse) =>
-        val left = Parser.oneOf(as.map(_.fa.string))
-        val right = Parser.oneOf[Any](as.map(_.fa)).string
+    forAll(Gen.choose(0, 5).flatMap(Gen.listOfN(_, ParserGen.gen)), genString) { (as, toParse) =>
+      val left = Parser.oneOf(as.map(_.fa.string))
+      val right = Parser.oneOf[Any](as.map(_.fa)).string
 
-        assertEquals(
-          left.parse(toParse).leftMap(_.offsets),
-          right.parse(toParse).leftMap(_.offsets)
-        )
+      assertEquals(
+        left.parse(toParse).leftMap(_.offsets),
+        right.parse(toParse).leftMap(_.offsets)
+      )
     }
   }
 
@@ -2622,36 +2618,34 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("a context0 added is always at the top") {
-    forAll(ParserGen.gen0, Arbitrary.arbitrary[List[String]], Arbitrary.arbitrary[String]) {
-      (genP, ctx, str) =>
-        ctx.foldLeft(genP.fa)(_.withContext(_)).parse(str) match {
-          case Left(err) =>
-            err.expected.toList.foreach { exp =>
-              val ectx = exp.context
-              assert(ectx.length >= ctx.length)
-              exp.context.zip(ctx.reverse).foreach { case (l, r) =>
-                assertEquals(l, r)
-              }
+    forAll(ParserGen.gen0, Arbitrary.arbitrary[List[String]], genString) { (genP, ctx, str) =>
+      ctx.foldLeft(genP.fa)(_.withContext(_)).parse(str) match {
+        case Left(err) =>
+          err.expected.toList.foreach { exp =>
+            val ectx = exp.context
+            assert(ectx.length >= ctx.length)
+            exp.context.zip(ctx.reverse).foreach { case (l, r) =>
+              assertEquals(l, r)
             }
-          case _ => ()
-        }
+          }
+        case _ => ()
+      }
     }
   }
 
   property("a context added is always at the top") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[List[String]], Arbitrary.arbitrary[String]) {
-      (genP, ctx, str) =>
-        ctx.foldLeft(genP.fa)(_.withContext(_)).parse(str) match {
-          case Left(err) =>
-            err.expected.toList.foreach { exp =>
-              val ectx = exp.context
-              assert(ectx.length >= ctx.length)
-              exp.context.zip(ctx.reverse).foreach { case (l, r) =>
-                assertEquals(l, r)
-              }
+    forAll(ParserGen.gen, Arbitrary.arbitrary[List[String]], genString) { (genP, ctx, str) =>
+      ctx.foldLeft(genP.fa)(_.withContext(_)).parse(str) match {
+        case Left(err) =>
+          err.expected.toList.foreach { exp =>
+            val ectx = exp.context
+            assert(ectx.length >= ctx.length)
+            exp.context.zip(ctx.reverse).foreach { case (l, r) =>
+              assertEquals(l, r)
             }
-          case _ => ()
-        }
+          }
+        case _ => ()
+      }
     }
   }
 
@@ -2687,7 +2681,7 @@ class ParserTest extends munit.ScalaCheckSuite {
   }
 
   property("P.caret is the same as index + toCaretUnsafe") {
-    forAll(ParserGen.gen, Arbitrary.arbitrary[String]) { (p, input) =>
+    forAll(ParserGen.gen, genString) { (p, input) =>
       val v1 = p.fa.void
       val lm = LocationMap(input)
       val left = (v1 *> Parser.index).map(lm.toCaretUnsafe(_)).parse(input)