Scala Language
tuples

Opmerkingen

Een nieuwe Tuple maken

Een tupel is een heterogene verzameling van twee tot tweeëntwintig waarden. Een tupel kan worden gedefinieerd met behulp van haakjes. Voor tupels van maat 2 (ook wel een 'paar' genoemd) is er een pijlsyntaxis.

scala> val x = (1, "hello") 
x: (Int, String) = (1,hello)
scala> val y = 2 -> "world" 
y: (Int, String) = (2,world)
scala> val z = 3 → "foo"     //example of using U+2192 RIGHTWARD ARROW
z: (Int, String) = (3,foo)

x is een tupel van maat twee. Gebruik ._1 en met ._22 om toegang te krijgen tot de elementen van een tuple. We kunnen bijvoorbeeld x._1 om toegang te krijgen tot het eerste element van de x tuple. x._2 toegang tot het tweede element. Eleganter kunt u tuple-extractors gebruiken .

De pijlsyntaxis voor het maken van tupels van grootte twee wordt voornamelijk gebruikt in Kaarten, die collecties zijn van (key -> value) paren:

scala> val m = Map[Int, String](2 -> "world")
m: scala.collection.immutable.Map[Int,String] = Map(2 -> world)

scala> m + x
res0: scala.collection.immutable.Map[Int,String] = Map(2 -> world, 1 -> hello)

scala> (m + x).toList
res1: List[(Int, String)] = List((2,world), (1,hello))

De syntaxis voor het paar op de kaart is de syntaxis van de pijl, waardoor duidelijk wordt dat 1 de sleutel is en a de waarde is die aan die sleutel is gekoppeld.

Tuples binnen collecties

Tuples worden vaak gebruikt binnen collecties, maar ze moeten op een specifieke manier worden behandeld. Bijvoorbeeld, gegeven de volgende lijst met tupels:

scala> val l = List(1 -> 2, 2 -> 3, 3 -> 4)
l: List[(Int, Int)] = List((1,2), (2,3), (3,4))

Het lijkt misschien logisch om de elementen samen te voegen met impliciet tuple-uitpakken:

scala> l.map((e1: Int, e2: Int) => e1 + e2)

Dit resulteert echter in de volgende fout:

<console>:9: error: type mismatch;
 found   : (Int, Int) => Int
 required: ((Int, Int)) => ?
              l.map((e1: Int, e2: Int) => e1 + e2)

Scala kan de tupels niet op deze manier impliciet uitpakken. We hebben twee opties om deze kaart te repareren. De eerste is om de positionele accessors _1 en _2 :

scala> l.map(e => e._1 + e._2)
res1: List[Int] = List(3, 5, 7)

De andere optie is om een case statement te gebruiken om de tupels uit te pakken met behulp van patroonovereenkomst:

scala> l.map{ case (e1: Int, e2: Int) => e1 + e2}
res2: List[Int] = List(3, 5, 7)

Deze beperkingen gelden voor elke hogere-orde-functie die wordt toegepast op een verzameling tupels.