Scala Language
Tuplas

Observaciones

Creando un nuevo tuple

Una tupla es una colección heterogénea de dos a veintidós valores. Una tupla se puede definir utilizando paréntesis. Para tuplas de tamaño 2 (también llamadas 'par') hay una sintaxis de flecha.

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 es una tupla de tamaño dos. Para acceder a los elementos de una tupla use ._1 , a través de ._22 . Por ejemplo, podemos usar x._1 para acceder al primer elemento de la tupla x . x._2 accede al segundo elemento. Más elegantemente, puedes usar extractores de tuplas .

La sintaxis de la flecha para crear tuplas de tamaño dos se usa principalmente en Mapas, que son colecciones de pares (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 sintaxis para el par en el mapa es la sintaxis de la flecha, dejando claro que 1 es la clave y a es el valor asociado con esa clave.

Tuplas dentro de las colecciones

Las tuplas se usan a menudo dentro de las colecciones, pero deben manejarse de una manera específica. Por ejemplo, dada la siguiente lista de tuplas:

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

Puede parecer natural agregar los elementos juntos mediante el desempaquetado implícito de la tupla:

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

Sin embargo, esto resulta en el siguiente error:

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

Scala no puede desempaquetar implícitamente las tuplas de esta manera. Tenemos dos opciones para arreglar este mapa. El primero es usar los _1 posicionales _1 y _2 :

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

La otra opción es usar una declaración de case para descomprimir las tuplas usando un patrón de coincidencia:

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

Estas restricciones se aplican a cualquier función de orden superior aplicada a una colección de tuplas.