Scala Language
tupler

Anmärkningar

Skapa en ny Tuple

En tupel är en heterogen samling av två till tjugotvå värden. En tupel kan definieras med hjälp av parenteser. För tupar i storlek 2 (kallas också ett "par") finns det en pilsyntax.

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 är en tupel i storlek två. För att få tillgång till elementen i en tuple, använd ._1 , genom ._22 . Vi kan till exempel använda x._1 att komma åt det första elementet i x tupeln. x._2 öppnar det andra elementet. Mer elegant kan du använda tuple-extraherare .

Pilsyntaxen för att skapa tuples i storlek två används främst i Kartor, som är samlingar av (key -> value) par:

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))

Syntaxen för paret på kartan är pilsyntaxen, vilket gör det klart att 1 är nyckeln och a är värdet associerat med den tangenten.

Tuples inom samlingar

Tuples används ofta inom samlingar men de måste hanteras på ett specifikt sätt. Till exempel, med följande lista över tuples:

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

Det kan verka naturligt att lägga till elementen tillsammans med implicit tuple-packning:

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

Detta resulterar dock i följande fel:

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

Scala kan inte implicit packa upp tupplarna på detta sätt. Vi har två alternativ för att fixa den här kartan. Den första är att använda positionstillbehören _1 och _2 :

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

Det andra alternativet är att använda en case uttalande att packa tuplerna som använder mönstermatchning:

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

Dessa begränsningar gäller för alla högre ordningsfunktioner som tillämpas på en samling tuples.