¿Puedo nombrar una tupla (definir una estructura?) En Scala 2.8?

Question

No parece muy bueno para mí repetir siempre una definición de tupla de larga duración cada vez que lo necesito. ¿Puedo simplemente nombrarlo y usarlo como un nombre de tipo? Sería bueno para nombrar sus campos también en lugar de utilizar ._1, etc. ._2

Answer 1

En cuanto a su primera pregunta, sólo tiene que utilizar un tipo de alias:

type KeyValue = (Int, String) 

Y, por supuesto, Scala es una orientada a objetos del lenguaje, por lo que en cuanto a su segunda acerca de cómo especializar una tupla, la palabra mágica es la herencia :

case class KeyValue(key: Int, value: String) extends (Int, String)(key, value) 

Eso es todo. La clase ni siquiera necesita un cuerpo.

val kvp = KeyValue(42, "Hello") 
kvp._1 // => res0: Int = 42 
kvp.value // => res1: String = "Hello" 

Tenga en cuenta, sin embargo, que la herencia de clases de caso (que es Tuple2), es obsoleto y puede ser rechazado en el futuro. Aquí está el compilador de advertencia que te pasa por la definición de la clase anterior:

advertencia: Clase caso class KV tiene caso ancestro clase class Tuple2. Esto ha sido desaprobado por complicar indebidamente tanto el uso como la implementación. En su lugar, debe utilizar extractores para la coincidencia de patrones en nodos de hoja.

Answer 2

Alias ​​de tipo está bien para nombrar su Tuple, pero intente utilizar una clase de caso en su lugar. Usted será capaz de utilizar parámetros con nombre

Ejemplo con tupla:

def foo(a : Int) : (Int, String) = { 
    (a,"bar") 
} 
val res = foo(1) 
val size = res._1 
val name= res._2 

Con una clase de caso:

case class Result(size : Int , name : String) 
def foo(a : Int) : Result = { 
    Result(a,"bar") 
} 
val res = foo(1) 
val size = res.size 
val name= res.name 

Answer 3

he aquí una solución que crea un alias de tipo y un objeto de fábrica.

scala> type T = (Int, String)       
defined type alias T 

scala> object T { def apply(i: Int, s: String): T = (i, s) } 
defined module T 

scala> new T(1, "a") 
res0: (Int, String) = (1,a) 

scala> T(1, "a") 
res1: (Int, String) = (1,a) 

Sin embargo, como han mencionado otros, es probable que solo deba crear una clase de caso.

Answer 4

Aunque, como han dicho otros, las clases explícitas (casos) son las mejores en el sentido general.

Sin embargo, para los escenarios localizados lo que puede hacer es utilizar el tuple extractor para mejorar la legibilidad del código:

val (first, second) = incrementPair(3, 4) 
println(s"$first ... $second") 

Dado un método de devolución de una tupla:

def incrementPair(pair: (Int, Int)) : (Int, Int) = { 
    val (first, second) = pair 
    (first + 1, second + 1) 
}