Böyle bir grup içinde bir kelimenin ilk harfi ve harfleri arasında bir eşleşme bulmak mümkün olmak istiyorum "ABC". Yalancı, bu bir şey gibi görünebilir:

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

Ama nasıl Java yerine Scala ilk harfi tutacağım? Nasıl düzenli ifade doğru ifade ederim? case class içinde bunu yapmak mümkün mü?

Sürüm 2.10, Scala dize ilişkilendirme özelliği kullanabilirsiniz:

implicit class Regex(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

Daha da iyisi:

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

Aynı zamanda daha ayrıntılı ve bağlayıcı mekanizmaları ayarlamak için:

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

Dynamic ile neyin mümkün olduğuna dair etkileyici bir örnek blog yazısı gösterilirIntroduction 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")
  }
}