Comment faire correspondre des modèles à l'aide d'une expression régulière dans Scala?

J'aimerais pouvoir trouver une correspondance entre la première lettre d'un mot et l'une des lettres d'un groupe tel que "ABC". En pseudocode, cela pourrait ressembler à quelque chose comme:

case Process(word) =>
   word.firstLetter match {
      case([a-c][A-C]) =>
      case _ =>
   }
}

Mais comment récupérer la première lettre dans Scala au lieu de Java? Comment exprimer correctement l'expression régulière? Est-il possible de faire cela dans une classe de cas ?

Vous pouvez le faire car les expressions régulières définissent des extracteurs, mais vous devez d'abord définir le modèle d'expression régulière. Je n'ai pas accès à un REPL Scala pour tester cela mais quelque chose comme ça devrait fonctionner.

val Pattern = "([a-cA-C])".r
word.firstLetter match {
   case Pattern(c) => c bound to capture group here
   case _ =>
}

Depuis la version 2.10, on peut utiliser la fonction d'interpolation de chaîne de Scala:

implicit class RegexOps(sc: StringContext) {
  def r = new util.matching.Regex(sc.parts.mkString, sc.parts.tail.map(_ => "x"): _*)
}

scala> "123" match { case r"\d+" => true case _ => false }
res34: Boolean = true

Mieux encore, on peut lier des groupes d'expressions régulières:

scala> "123" match { case r"(\d+)$d" => d.toInt case _ => 0 }
res36: Int = 123

scala> "10+15" match { case r"(\d\d)${first}\+(\d\d)${second}" => first.toInt+second.toInt case _ => 0 }
res38: Int = 25

Il est également possible de définir des mécanismes de liaison plus détaillés:

scala> object Doubler { def unapply(s: String) = Some(s.toInt*2) }
defined module Doubler

scala> "10" match { case r"(\d\d)${Doubler(d)}" => d case _ => 0 }
res40: Int = 20

scala> object isPositive { def unapply(s: String) = s.toInt >= 0 }
defined module isPositive

scala> "10" match { case r"(\d\d)${d @ isPositive()}" => d.toInt case _ => 0 }
res56: Int = 10

Un exemple impressionnant de ce qui est possible avec Dynamicest montré dans l'article de blog Introduction to Type Dynamic :

object T {

  class RegexpExtractor(params: List[String]) {
    def unapplySeq(str: String) =
      params.headOption flatMap (_.r unapplySeq str)
  }

  class StartsWithExtractor(params: List[String]) {
    def unapply(str: String) =
      params.headOption filter (str startsWith _) map (_ => str)
  }

  class MapExtractor(keys: List[String]) {
    def unapplySeq[T](map: Map[String, T]) =
      Some(keys.map(map get _))
  }

  import scala.language.dynamics

  class ExtractorParams(params: List[String]) extends Dynamic {
    val Map = new MapExtractor(params)
    val StartsWith = new StartsWithExtractor(params)
    val Regexp = new RegexpExtractor(params)

    def selectDynamic(name: String) =
      new ExtractorParams(params :+ name)
  }

  object p extends ExtractorParams(Nil)

  Map("firstName" -> "John", "lastName" -> "Doe") match {
    case p.firstName.lastName.Map(
          Some(p.Jo.StartsWith(fn)),
          Some(p.`.*(\\w)$`.Regexp(lastChar))) =>
      println(s"Match! $fn ...$lastChar")
    case _ => println("nope")
  }
}

Comme l'a souligné delnan, le matchmot - clé dans Scala n'a rien à voir avec les expressions régulières. Pour savoir si une chaîne correspond à une expression régulière, vous pouvez utiliser la String.matchesméthode. Pour savoir si une chaîne commence par un a, b ou c en minuscule ou en majuscule, l'expression régulière ressemblerait à ceci:

word.matches("[a-cA-C].*")

Vous pouvez lire cette expression régulière comme "l'un des caractères a, b, c, A, B ou C suivi de n'importe quoi" ( .signifie "n'importe quel caractère" et *signifie "zéro fois ou plus", donc ". *" Est une chaîne) .

Pour développer un peu la réponse d'Andrew : Le fait que les expressions régulières définissent des extracteurs peut être utilisé pour décomposer très bien les sous-chaînes correspondant à l'expression régulière en utilisant la correspondance de motifs de Scala, par exemple:

val Process = """([a-cA-C])([^\s]+)""".r // define first, rest is non-space
for (p <- Process findAllIn "aha bah Cah dah") p match {
  case Process("b", _) => println("first: 'a', some rest")
  case Process(_, rest) => println("some first, rest: " + rest)
  // etc.
}

String.matches est le moyen de faire la correspondance de motifs dans le sens de l'expression régulière.

Mais en passant, word.firstLetter en vrai code Scala ressemble à:

word(0)

Scala traite les chaînes comme une séquence de caractères, donc si pour une raison quelconque vous vouliez explicitement obtenir le premier caractère de la chaîne et le faire correspondre, vous pouvez utiliser quelque chose comme ceci:

"Cat"(0).toString.matches("[a-cA-C]")
res10: Boolean = true

Je ne propose pas cela comme moyen général de faire la correspondance de motifs regex, mais cela correspond à votre approche proposée pour trouver d'abord le premier caractère d'une chaîne, puis le faire correspondre à une expression régulière.

EDIT: Pour être clair, la façon dont je ferais cela est, comme d'autres l'ont dit:

"Cat".matches("^[a-cA-C].*")
res14: Boolean = true

Je voulais juste montrer un exemple aussi proche que possible de votre pseudo-code initial. À votre santé!

Notez que l'approche de la réponse de @ AndrewMyers fait correspondre la chaîne entière à l'expression régulière, avec pour effet d'ancrer l'expression régulière aux deux extrémités de la chaîne en utilisant ^et $. Exemple:

scala> val MY_RE = "(foo|bar).*".r
MY_RE: scala.util.matching.Regex = (foo|bar).*

scala> val result = "foo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = foo

scala> val result = "baz123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

scala> val result = "abcfoo123" match { case MY_RE(m) => m; case _ => "No match" }
result: String = No match

Et sans .*à la fin:

scala> val MY_RE2 = "(foo|bar)".r
MY_RE2: scala.util.matching.Regex = (foo|bar)

scala> val result = "foo123" match { case MY_RE2(m) => m; case _ => "No match" }
result: String = No match

Tout d'abord, nous devons savoir que l'expression régulière peut être utilisée séparément. Voici un exemple:

import scala.util.matching.Regex
val pattern = "Scala".r // <=> val pattern = new Regex("Scala")
val str = "Scala is very cool"
val result = pattern findFirstIn str
result match {
  case Some(v) => println(v)
  case _ =>
} // output: Scala

Deuxièmement, nous devrions remarquer que combiner une expression régulière avec une correspondance de modèle serait très puissant. Voici un exemple simple.

val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r
"2014-11-20" match {
  case date(year, month, day) => "hello"
} // output: hello

En fait, l'expression régulière elle-même est déjà très puissante; la seule chose que nous devons faire est de le rendre plus puissant par Scala. Voici d'autres exemples dans le document Scala: http://www.scala-lang.org/files/archive/api/current/index.html#scala.util.matching.Regex