Use infix function instead backticks.

Author: two-horned

artifact/src/test/scala/BasicCombinatorsTest.scala

@@ -12,61 +12,61 @@ trait BasicCombinatorTests {
   describe("parser \"abc\"") {
     val p = 'a' ~ 'b' ~ 'c'
 
-    p `shouldParse` "abc"
-    p `shouldNotParse` "abcd"
+    p shouldParse "abc"
+    p shouldNotParse "abcd"
   }
 
   describe("parser \"ab | ac\"") {
     val p = ('a' ~ 'b') | ('a' ~ 'c')
-    p `shouldParse` "ab"
-    p `shouldParse` "ac"
-    p `shouldNotParse` "bc"
-    p `shouldNotParse` "a"
-    p `shouldNotParse` "abc"
+    p shouldParse "ab"
+    p shouldParse "ac"
+    p shouldNotParse "bc"
+    p shouldNotParse "a"
+    p shouldNotParse "abc"
   }
 
   describe("parser \"baaa | ba\"") {
     val p = ('b' ~ 'a' ~ 'a' ~ 'a') | 'b' ~ 'a'
-    p `shouldParse` "baaa"
-    p `shouldParse` "ba"
-    ((p ~ 'c' ~ 'o') | (p ~ 'c')) `shouldParse` "bac"
-    ((p ~ 'c' ~ 'o') | (p ~ 'c')) `shouldParse` "baco"
+    p shouldParse "baaa"
+    p shouldParse "ba"
+    ((p ~ 'c' ~ 'o') | (p ~ 'c')) shouldParse "bac"
+    ((p ~ 'c' ~ 'o') | (p ~ 'c')) shouldParse "baco"
   }
 
   describe("parser \"(baaa | ba) aa\"") {
     val p = ("baaa" | "ba") ~ "aa"
-    p `shouldParse` "baaaaa"
-    p `shouldParse` "baaa"
+    p shouldParse "baaaaa"
+    p shouldParse "baaa"
   }
 
   describe("parser \"succeed(a) b\"") {
     val p = succ('a') ~ 'b'
-    p `shouldParse` "b"
-    p `shouldNotParse` ""
+    p shouldParse "b"
+    p shouldNotParse ""
   }
 
   describe("parser \"succeed(a) succeed(b)\"") {
     val p = succ('a') ~ succ('b')
-    p `shouldParse` ""
+    p shouldParse ""
   }
 
   describe("parser \"succeed(a) | succeed(b)\"") {
     val p = succ('a') | succ('b')
-    p `shouldParse` ""
+    p shouldParse ""
   }
 
   describe("parser \"(a a a | a a)+") {
     val p = 'a' ~ 'a' ~ 'a' | 'a' ~ 'a'
-    describe("some(_)") { some(p) `shouldParse` "aaaa" }
-    describe("_ ~ 'b'") { (p ~ 'b') `shouldParse` "aaab" }
+    describe("some(_)") { some(p) shouldParse "aaaa" }
+    describe("_ ~ 'b'") { (p ~ 'b') shouldParse "aaab" }
     describe("some(_) ~ 'b'") {
-      (some(p) ~ 'b') `shouldParse` "aab"
-      (some(p) ~ 'b') `shouldParse` "aaab"
-      (some(p) ~ 'b') `shouldParse` "aaaaab"
+      (some(p) ~ 'b') shouldParse "aab"
+      (some(p) ~ 'b') shouldParse "aaab"
+      (some(p) ~ 'b') shouldParse "aaaaab"
     }
     describe("some(_ ~ 'a') ~ 'b'") {
-      (some(p ~ 'a') ~ 'b') `shouldParse` "aaaab"
-      (some(p ~ 'a') ~ 'b') `shouldParse` "aaab"
+      (some(p ~ 'a') ~ 'b') shouldParse "aaaab"
+      (some(p ~ 'a') ~ 'b') shouldParse "aaab"
     }
   }
 
@@ -75,12 +75,12 @@ trait BasicCombinatorTests {
 
     val largeInput = List.fill(100)('a').mkString
 
-    p `shouldParse` "a"
-    p `shouldParse` "aaaaaa"
-    p `shouldParse` largeInput
-    p `shouldNotParse` ""
-    p `shouldNotParse` "b" + largeInput
-    p `shouldNotParse` largeInput + "b"
+    p shouldParse "a"
+    p shouldParse "aaaaaa"
+    p shouldParse largeInput
+    p shouldNotParse ""
+    p shouldNotParse "b" + largeInput
+    p shouldNotParse largeInput + "b"
   }
 
 }

artifact/src/test/scala/CustomMatchers.scala

@@ -12,18 +12,18 @@ trait CustomMatchers[+P <: Parsers](val parsers: P) extends Matchers {
   import parsers.{Elem, Parser, accepts, isSuccess, parse}
 
   extension [T](p: => Parser[T]) {
-    def shouldParse(s: Iterable[Elem], tags: Tag*) =
+    infix def shouldParse(s: Iterable[Elem], tags: Tag*) =
       it(s"""should parse "$s" """, tags*) {
-        accepts(p, s) `shouldBe` true
+        accepts(p, s) shouldBe true
       }
-    def shouldNotParse(s: Iterable[Elem], tags: Tag*) =
+    infix def shouldNotParse(s: Iterable[Elem], tags: Tag*) =
       it(s"""should not parse "$s" """, tags*) {
-        accepts(p, s) `shouldBe` false
+        accepts(p, s) shouldBe false
       }
     // for unambiguous parses
-    def shouldParseWith(s: Iterable[Elem], result: T) =
+    infix def shouldParseWith(s: Iterable[Elem], result: T) =
       it(s"""should parse "$s" with correct result""") {
-        parse(p, s) `shouldBe` List(result)
+        parse(p, s) shouldBe List(result)
       }
   }