Defer codePointWhere and charWhere description

Improving performance when those descriptions are not needed

Base/src/main/scala-2/package.scala

@@ -72,10 +72,8 @@ package object stringContextParserCombinator {
 			case ExpectingSet.Empty() => {
 				c.abort(c.enclosingPosition, "Parsing failed")
 			}
-			case ExpectingSet.NonEmpty(position, descriptions) => {
-				// `sorted` to make result deterministic
-				val descriptions2 = descriptions.toList.sortBy(_.toString).mkString("Expected ", " or ", "")
-				c.abort(position, descriptions2)
+			case set @ ExpectingSet.NonEmpty(position, _) => {
+				c.abort(position, set.renderDescriptions)
 			}
 		}
 	}

Base/src/main/scala-3/package.scala

@@ -17,10 +17,8 @@ package object stringContextParserCombinator {
 			case ExpectingSet.Empty() => {
 				scala.quoted.quotes.reflect.report.errorAndAbort("Parsing failed")
 			}
-			case ExpectingSet.NonEmpty(position, descriptions) => {
-				// `sorted` to make result deterministic
-				val descriptions2 = descriptions.toList.sortBy(_.toString).mkString("Expected ", " or ", "")
-				q.reflect.report.errorAndAbort(descriptions2, position + 1)
+			case set @ ExpectingSet.NonEmpty(position, _) => {
+				q.reflect.report.errorAndAbort(set.renderDescriptions, position + 1)
 			}
 		}
 	}

Base/src/main/scala/Expecting.scala

@@ -0,0 +1,10 @@
+package name.rayrobdod.stringContextParserCombinator
+
+private[stringContextParserCombinator]
+final case class Expecting[Pos](
+	val description:ExpectingDescription,
+	val position:Pos,
+) {
+	def where(condition:ExpectingDescription) =
+		new Expecting(description.where(condition), position)
+}

Base/src/main/scala/ExpectingDescription.scala

@@ -0,0 +1,42 @@
+package name.rayrobdod.stringContextParserCombinator
+
+/** Represents a textual description of under what conditions a parser would return success */
+private[stringContextParserCombinator]
+sealed abstract class ExpectingDescription {
+	private[stringContextParserCombinator]
+	def where(condition:ExpectingDescription):ExpectingDescription
+	private[stringContextParserCombinator]
+	def render:String
+}
+
+private[stringContextParserCombinator]
+object ExpectingDescription {
+	def apply(backing: String): ExpectingDescription = {
+		new ExpectingDescription {
+			override def where(condition:ExpectingDescription):ExpectingDescription = {
+				ExpectingDescription(s"${this.render} where ${condition.render}")
+			}
+			override def render: String = {
+				backing
+			}
+			override def toString: String = {
+				s"ExpectingDescription.eager($backing)"
+			}
+		}
+	}
+
+	def delayed(backingFn: => String): ExpectingDescription = {
+		new ExpectingDescription {
+			private lazy val backingValue = backingFn
+			override def where(condition:ExpectingDescription):ExpectingDescription = {
+				ExpectingDescription.delayed(s"${this.render} where ${condition.render}")
+			}
+			override def render: String = {
+				backingValue
+			}
+			override def toString: String = {
+				s"ExpectingDescription.delayed(<fn>)"
+			}
+		}
+	}
+}

Base/src/main/scala/ExpectingSet.scala

@@ -8,7 +8,10 @@ sealed trait ExpectingSet[Pos] {
 
 private[stringContextParserCombinator]
 object ExpectingSet {
-	final case class NonEmpty[Pos : Ordering](val maxPosition:Pos, val descriptionsAtMaxPosition:Set[ExpectingDescription]) extends ExpectingSet[Pos] {
+	final case class NonEmpty[Pos : Ordering](
+			val maxPosition:Pos,
+			val descriptionsAtMaxPosition:Seq[ExpectingDescription]
+	) extends ExpectingSet[Pos] {
 		override def ++(other: ExpectingSet[Pos]): ExpectingSet[Pos] = {
 			import Ordering.Implicits.infixOrderingOps
 			other match {
@@ -22,19 +25,29 @@ object ExpectingSet {
 		override def mapDescriptions(fn: ExpectingDescription => ExpectingDescription):ExpectingSet[Pos] = {
 			new NonEmpty[Pos](maxPosition, descriptionsAtMaxPosition.map(fn))
 		}
+
+		def renderDescriptions: String =
+			// `sorted` and `distinct` to make result deterministic
+			descriptionsAtMaxPosition
+				.view
+				.map(_.render)
+				.distinct
+				.toList
+				.sorted
+				.mkString("Expected ", " or ", "")
 	}
 
 	final case class Empty[Pos]() extends ExpectingSet[Pos] {
 		override def ++(other: ExpectingSet[Pos]):ExpectingSet[Pos] = other
 		override def mapDescriptions(fn: ExpectingDescription => ExpectingDescription):ExpectingSet[Pos] = this
 	}
 
-	def apply[Pos : Ordering](a:Expecting[Pos]):ExpectingSet[Pos] = new NonEmpty(a.position, Set(a.description))
+	def apply[Pos : Ordering](a:Expecting[Pos]):ExpectingSet[Pos] = new NonEmpty(a.position, Seq(a.description))
 
 	def fromSpecific[Pos : Ordering](as:Iterable[Expecting[Pos]]):ExpectingSet[Pos] = {
 		if (as.nonEmpty) {
 			val maxPosition = as.map(_.position).reduce({(a, b) => if (Ordering[Pos].gt(a, b)) a else b})
-			new NonEmpty(maxPosition, as.collect({case ex if ex.position == maxPosition => ex.description}).toSet)
+			new NonEmpty(maxPosition, as.collect({case ex if ex.position == maxPosition => ex.description}).toSeq)
 		} else {
 			new Empty
 		}

Base/src/main/scala/Extractor.scala

@@ -69,9 +69,8 @@ final class Extractor[Expr[_], Type[_], -A] private[stringContextParserCombinato
 			case f:Failure[Int] => {
 				val msg = f.expecting match {
 					case ExpectingSet.Empty() => "Parsing Failed"
-					case ExpectingSet.NonEmpty(position, descriptions) => {
-						// `sorted` to make result deterministic
-						val exp = descriptions.toList.sortBy(_.toString).mkString("Expected ", " or ", "")
+					case set @ ExpectingSet.NonEmpty(position, _) => {
+						val exp = set.renderDescriptions
 						val instr = sc.parts.mkString(argString)
 						val pointer = (" " * position) + "^"
 

Base/src/main/scala/Interpolator.scala

@@ -65,9 +65,8 @@ final class Interpolator[-Expr, +A] private[stringContextParserCombinator] (
 			case f:Failure[Int] => {
 				val msg = f.expecting match {
 					case ExpectingSet.Empty() => "Parsing Failed"
-					case ExpectingSet.NonEmpty(position, descriptions) => {
-						// `sorted` to make result deterministic
-						val exp = descriptions.toList.sortBy(_.toString).mkString("Expected ", " or ", "")
+					case set @ ExpectingSet.NonEmpty(position, _) => {
+						val exp = set.renderDescriptions
 						val instr = sc.parts.mkString(argString)
 						val pointer = (" " * position) + "^"
 

Base/src/main/scala/internal/package.scala

@@ -51,47 +51,48 @@ package object internal {
 	 * Returns a string that describes which codepoints match the predicate
 	 */
 	private def describeCodepointPredicate(predicate:Int => Boolean, domainMax: Int):ExpectingDescription = {
-		val builder = new StringBuilder()
-		var inMatchingBlock:Boolean = false
-		var firstCharOfBlock:Int = 0
-
-		(0 to domainMax).foreach({c =>
-			if (predicate(c)) {
-				if (inMatchingBlock) {
-					// continue
-				} else {
-					inMatchingBlock = true
-					firstCharOfBlock = c
-				}
-			} else {
-				if (inMatchingBlock) {
-					builder.++=("'")
-					builder.++=(escape(firstCharOfBlock))
-					if (firstCharOfBlock != c - 1) {
-						builder.++=("'<=c<='")
-						builder.++=(escape((c - 1)))
+		ExpectingDescription.delayed({
+			val builder = new StringBuilder()
+			var inMatchingBlock:Boolean = false
+			var firstCharOfBlock:Int = 0
+
+			(0 to domainMax).foreach({c =>
+				if (predicate(c)) {
+					if (inMatchingBlock) {
+						// continue
+					} else {
+						inMatchingBlock = true
+						firstCharOfBlock = c
 					}
-					builder.++=("' or ")
-					inMatchingBlock = false
 				} else {
-					// continue
+					if (inMatchingBlock) {
+						builder.++=("'")
+						builder.++=(escape(firstCharOfBlock))
+						if (firstCharOfBlock != c - 1) {
+							builder.++=("'<=c<='")
+							builder.++=(escape((c - 1)))
+						}
+						builder.++=("' or ")
+						inMatchingBlock = false
+					} else {
+						// continue
+					}
 				}
+			})
+			if (inMatchingBlock) {
+				builder.++=("'")
+				builder.++=(escape(firstCharOfBlock))
+				builder.++=("'<=c<='")
+				builder.++=(escape(domainMax))
+				builder.++=("' or ")
 			}
-		})
-		if (inMatchingBlock) {
-			builder.++=("'")
-			builder.++=(escape(firstCharOfBlock))
-			builder.++=("'<=c<='")
-			builder.++=(escape(domainMax))
-			builder.++=("' or ")
-		}
-		ExpectingDescription(
+
 			if (builder.length > 4) {
 				builder.substring(0, builder.length - 4)
 			} else {
 				"nothing"
 			}
-		)
+		})
 	}
 
 	/* * * Leaf parsers * * */

CHANGES.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [Unreleased-Major]
+* Improve performance of `codePointWhere` and `charWhere` if default error message is not needed
+
 ## [Unreleased]
 * Add symbolic operators to Parser, Extractor and Interpolator
   * `<~>` and `<|>` as aliases for `andThen` and `orElse`, respectively