Puis-je nommer un tuple (définir une structure?) Dans Scala 2.8?

Question

Il ne me semble pas très bon de toujours répéter une définition de ligne de tuple chaque fois que j'en ai besoin. Puis-je simplement le nommer et l'utiliser comme nom de type? Ce serait bien de nommer ses champs aussi au lieu d'utiliser ._1, ._2 etc.

Answer 1

En ce qui concerne votre première question, vous pouvez simplement utiliser un alias de type:

type KeyValue = (Int, String) 

Et, bien sûr, Scala est un langage orienté objet, donc en ce qui concerne votre deuxième sur la façon de se spécialiser un tuple, le mot magique est héritage:

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

Voilà. La classe n'a même pas besoin d'un corps.

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

Notez, cependant, que des classes héritant de cas (ce qui est Tuple2), est dépréciée et peut être rejeté dans l'avenir. Voici le compilateur d'avertissement que vous obtenez pour la définition de classe ci-dessus:

avertissement: classe de cas class KV a le cas ancêtre de classe class Tuple2. Cela a été déprécié pour compliquer indûment à la fois l'utilisation et la mise en œuvre. Vous devriez plutôt utiliser des extracteurs pour la correspondance de motifs sur les nœuds non-feuilles.

Answer 2

L'alias de type est bon pour nommer votre Tuple, mais essayez plutôt d'utiliser une classe de casse. Vous pourrez utiliser des paramètres nommés

Exemple avec tuple:

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

Avec une classe de cas:

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

Voici une solution qui crée un alias de type et un objet usine.

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) 

Cependant, comme d'autres l'ont mentionné, vous devriez probablement créer une classe de cas.

Answer 4

Bien que d'autres l'aient dit, les classes explicites (cas) sont les meilleures au sens général.

Cependant pour des scénarios localisés ce que vous pouvez faire est d'utiliser la tuple extractor pour améliorer la lisibilité du code:

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

Compte tenu d'une méthode retournant un tuple:

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