Scala Language
extractors

Syntaxis

• val extractor (extractValue1, _ / * genegeerde tweede geëxtraheerde waarde * /) = valueToBeExtracted
• valueToBeExtracted match {case extractor (extractValue1, _) => ???}
• val (tuple1, tuple2, tuple3) = tupleWith3Elements
• object Foo {def unapply (foo: Foo): Option [String] = Some (foo.x); }

Tuple Extractors

x en y worden uit de tuple gehaald:

val (x, y) = (1337, 42)
// x: Int = 1337
// y: Int = 42

Gebruik _ om een waarde te negeren:

val (_, y: Int) = (1337, 42)
// y: Int = 42

Een extractor uitpakken:

val myTuple = (1337, 42)
myTuple._1  // res0: Int = 1337
myTuple._2  // res1: Int = 42

Merk op dat tupels een maximale lengte van 22 hebben, en dus ._1 tot ._22 zullen werken (ervan uitgaande dat de tuple minstens die grootte heeft).

Tuple-extractors kunnen worden gebruikt om symbolische argumenten te geven voor letterlijke functies:

val persons = List("A." -> "Lovelace", "G." -> "Hopper")
val names = List("Lovelace, A.", "Hopper, G.")

assert {
  names ==
    (persons map { name =>
      s"${name._2}, ${name._1}"
    })
}

assert {
  names ==
    (persons map { case (given, surname) =>
      s"$surname, $given"
    })
}

Case Class Extractors

Een casusklasse is een klasse met veel standaard standaardcode automatisch inbegrepen. Een voordeel hiervan is dat Scala het gemakkelijk maakt om extractors met case-klassen te gebruiken.

case class Person(name: String, age: Int)  // Define the case class
val p = Person("Paola", 42)  // Instantiate a value with the case class type

val Person(n, a) = p  // Extract values n and a
// n: String = Paola
// a: Int = 42

Op dit moment zijn zowel n als a val s in het programma en zijn ze als zodanig toegankelijk: er wordt gezegd dat ze zijn 'geëxtraheerd' uit p. Voortzetting van:

val p2 = Person("Angela", 1337)

val List(Person(n1, a1), Person(_, a2)) = List(p, p2)
// n1: String = Paola
// a1: Int = 42
// a2: Int = 1337

Hier zien we twee belangrijke dingen:

• Extractie kan op 'diepe' niveaus plaatsvinden: eigenschappen van geneste objecten kunnen worden geëxtraheerd.
• Niet alle elementen moeten worden geëxtraheerd. Het jokerteken _ geeft aan dat die bepaalde waarde van alles kan zijn en wordt genegeerd. Er is geen val gemaakt.

Dit kan met name het matchen over collecties gemakkelijk maken:

val ls = List(p1, p2, p3)  // List of Person objects
ls.map(person => person match {
  case Person(n, a) => println("%s is %d years old".format(n, a))
})

Hier hebben we code die de extractor gebruikt om expliciet te controleren of die person een Person object is en onmiddellijk de variabelen verwijderen waar we om geven: n en a .

Unapply - Custom Extractors

Een aangepaste extractie kan worden geschreven door de niet- unapply methode te implementeren en een waarde van het type Option retourneren:

class Foo(val x: String)

object Foo {
  def unapply(foo: Foo): Option[String] = Some(foo.x)
}

new Foo("42") match {
  case Foo(x) => x
}
// "42"

Het type retour dat niet van unapply kan iets anders zijn dan Option , op voorwaarde dat het geretourneerde type de methoden get en is isEmpty biedt. In dit voorbeeld wordt Bar gedefinieerd met deze methoden en wordt een exemplaar van Bar unapply geretourneerd:

class Bar(val x: String) {
  def get = x
  def isEmpty = false
}

object Bar {
  def unapply(bar: Bar): Bar = bar
}

new Bar("1337") match {
  case Bar(x) => x
}
// "1337"

Het unapply kan ook een Boolean , wat een speciaal geval is dat niet isEmpty vereisten voor get en is isEmpty . Merk echter in dit voorbeeld op dat DivisibleByTwo een object is, geen klasse, en geen parameter aanneemt (en daarom kan die parameter niet worden gebonden):

object DivisibleByTwo {
  def unapply(num: Int): Boolean = num % 2 == 0
}

4 match {                        
  case DivisibleByTwo() => "yes" 
  case _ => "no"
}
// yes

3 match {
  case DivisibleByTwo() => "yes"
  case _ => "no"
}
// no

Vergeet niet dat dit niet van unapply is op het unapply object van een klasse, niet op de klasse. Het bovenstaande voorbeeld zal duidelijk zijn als u dit onderscheid begrijpt.

Extractor Infix-notatie

Als een case-klasse exact twee waarden heeft, kan de extractor worden gebruikt in infix-notatie.

case class Pair(a: String, b: String)
val p: Pair = Pair("hello", "world")
val x Pair y = p
//x: String = hello
//y: String = world

Elke extractor die een 2-tuple retourneert, kan op deze manier werken.

object Foo {
    def unapply(s: String): Option[(Int, Int)] = Some((s.length, 5))
}
val a Foo b = "hello world!"
//a: Int = 12
//b: Int = 5

Regex Extractors

Een reguliere expressie met gegroepeerde delen kan als extractor worden gebruikt:

scala> val address = """(.+):(\d+)""".r
address: scala.util.matching.Regex = (.+):(\d+)

scala> val address(host, port) = "some.domain.org:8080"
host: String = some.domain.org
port: String = 8080

Merk op dat wanneer het niet wordt geëvenaard, een MatchError wordt gegooid tijdens runtime:

scala> val address(host, port) = "something not a host and port"
scala.MatchError: something not a host and port (of class java.lang.String)

Transformatieve extractors

Extractiegedrag kan worden gebruikt om willekeurige waarden uit hun invoer af te leiden. Dit kan handig zijn in scenario's waarin u wilt kunnen reageren op de resultaten van een transformatie in het geval dat de transformatie succesvol is.

Beschouw als voorbeeld de verschillende gebruikersnaamformaten die bruikbaar zijn in een Windows-omgeving :

object UserPrincipalName {
  def unapply(str: String): Option[(String, String)] = str.split('@') match {
    case Array(u, d) if u.length > 0 && d.length > 0 => Some((u, d))
    case _ => None
  }        
}

object DownLevelLogonName {
  def unapply(str: String): Option[(String, String)] = str.split('\\') match {
    case Array(d, u) if u.length > 0 && d.length > 0 => Some((d, u))
    case _ => None
  }
}

def getDomain(str: String): Option[String] = str match {
  case UserPrincipalName(_, domain) => Some(domain)
  case DownLevelLogonName(domain, _) => Some(domain)
  case _ => None
}

Het is zelfs mogelijk om een extractor te maken die beide gedragingen vertoont door de typen te verbreden waaraan het kan voldoen:

object UserPrincipalName {
  def unapply(obj: Any): Option[(String, String)] = obj match {
    case upn: UserPrincipalName => Some((upn.username, upn.domain))
    case str: String => str.split('@') match {
      case Array(u, d) if u.length > 0 && d.length > 0 => Some((u, d))
      case _ => None
    }
    case _ => None
  }        
}

In het algemeen, afzuigingen zijn gewoon een handige herformulering van de Option patroon, zoals toegepast bij methoden met namen als tryParse :

UserPrincipalName.unapply("user@domain") match {
  case Some((u, d)) => ???
  case None => ???
}