Jak sprawdzić, czy ciąg znaków w pełni pasuje do wyrażenia regularnego w Scali?

Załóżmy, że mam wzór Regex, do którego chcę dopasować wiele ciągów.

val Digit = """\d""".r

Chcę tylko sprawdzić, czy dany ciąg w pełni pasuje do wyrażenia regularnego. Jaki jest dobry i idiomatyczny sposób na zrobienie tego w Scali?

Wiem, że mogę dopasować wzorce na Regexes, ale w tym przypadku nie jest to zbyt przyjemne, ponieważ nie mam grup do wyodrębnienia:

scala> "5" match { case Digit() => true case _ => false }
res4: Boolean = true

Albo mogę wrócić do podstawowego wzorca Java:

scala> Digit.pattern.matcher("5").matches
res6: Boolean = true

co też nie jest eleganckie.

Czy jest lepsze rozwiązanie?

Odpowiadając na własne pytanie, użyję wzoru „odpicuj moją bibliotekę”

object RegexUtils {
  implicit class RichRegex(val underlying: Regex) extends AnyVal {
    def matches(s: String) = underlying.pattern.matcher(s).matches
  }
}

i używaj go w ten sposób

import RegexUtils._
val Digit = """\d""".r
if (Digit matches "5") println("match")
else println("no match")

chyba że ktoś wymyśli lepsze (standardowe) rozwiązanie.

Uwagi

• Nie starałem Stringsię ograniczyć zakresu potencjalnych skutków ubocznych.

• unapplySeq nie czyta zbyt dobrze w tym kontekście.

Nie znam Scali aż za dobrze, ale wygląda na to, że możesz po prostu zrobić:

"5".matches("\\d")

Bibliografia

• http://langref.org/scala/pattern-matching/matching

Aby uzyskać pełne dopasowanie, możesz użyć unapplySeq . Ta metoda próbuje dopasować cel (całe dopasowanie) i zwraca dopasowania.

scala> val Digit = """\d""".r
Digit: scala.util.matching.Regex = \d

scala> Digit unapplySeq "1"
res9: Option[List[String]] = Some(List())

scala> Digit unapplySeq "123"
res10: Option[List[String]] = None

scala> Digit unapplySeq "string"
res11: Option[List[String]] = None

  """\d""".r.unapplySeq("5").isDefined            //> res1: Boolean = true
  """\d""".r.unapplySeq("a").isDefined            //> res2: Boolean = false

Odpowiedź znajduje się w wyrażeniu regularnym:

val Digit = """^\d$""".r

Następnie użyj jednej z istniejących metod.

Korzystanie z biblioteki Standard Scala i wstępnie skompilowanego wzorca wyrażenia regularnego i dopasowania do wzorca (co jest najnowocześniejszym standardem Scala):

val digit = """(\d)""".r

"2" match {
  case digit( a) => println(a + " is Digit")
  case _ => println("it is something else")
}

więcej do przeczytania: http://www.scala-lang.org/api/2.12.1/scala/util/matching/index.html