Scala Language
Tuples

Remarques

Créer un nouveau tuple

Un tuple est une collection hétérogène de deux à vingt-deux valeurs. Un tuple peut être défini à l'aide de parenthèses. Pour les tuples de taille 2 (également appelée paire), il existe une syntaxe de flèche.

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 est un tuple de taille deux. Pour accéder aux éléments d'un tuple, utilisez ._1 , via ._22 . Par exemple, nous pouvons utiliser x._1 pour accéder au premier élément du tuple x . x._2 accède au second élément. Plus élégamment, vous pouvez utiliser des extracteurs de tuple .

La syntaxe de flèche pour créer des tuples de taille deux est principalement utilisée dans Maps, qui sont des collections de paires (key -> value) :

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

La syntaxe de la paire dans la carte est la syntaxe de la flèche, indiquant clairement que 1 est la clé et a la valeur associée à cette clé.

Tuples dans les collections

Les tuples sont souvent utilisés dans les collections, mais ils doivent être manipulés de manière spécifique. Par exemple, compte tenu de la liste suivante de tuples:

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

Il peut sembler naturel d’ajouter les éléments en utilisant le tuple-unpacking implicite:

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

Cependant, cela entraîne l'erreur suivante:

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

Scala ne peut pas implicitement déballer les tuples de cette manière. Nous avons deux options pour corriger cette carte. La première consiste à utiliser les accesseurs positionnels _1 et _2 :

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

L'autre option consiste à utiliser une instruction case pour décompresser les tuples à l'aide de la correspondance de modèle:

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

Ces restrictions s'appliquent à toute fonction d'ordre supérieur appliquée à une collection de tuples.