Puis-je nom d'un n-uplet (définir une structure?) en Scala 2.8?

Il n'est pas très bon pour moi de toujours répéter une ligne de long tuple définition à chaque fois que j'en ai besoin. Puis-je juste le nom et l'utiliser comme un type de nom? Serait bien de citer ses champs, au lieu d'utiliser ._1, ._2 etc.

InformationsquelleAutor Ivan | 2010-09-10

32

Concernant votre première question, vous pouvez tout simplement utiliser un alias de type:
```
type KeyValue = (Int, String)
```
Et, bien sûr, la 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)
```
Que c'est. 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"
```
Noter, cependant, que l'héritage de classes de cas (qui Tuple2 est), est obsolète et peut être rejetés dans l'avenir. Voici le message d'avertissement du compilateur que vous obtenez pour le ci-dessus la définition de la classe:

avertissement: le cas de la classe class KV a cas de la classe ancêtre class Tuple2. Cela a été supprimée pour alourdir à l'excès la fois sur l'usage et la mise en œuvre. Vous devez utiliser à la place d'extracteurs pour le filtrage sur les non-nœuds feuilles.

InformationsquelleAutor Jörg W Mittag
18

Type d'alias est très bien pour donner un nom à votre Tuple, mais essayez d'utiliser une classe de cas de la place. Vous serez en mesure d'utiliser des paramètres nommés

Exemple avec n-uplet:
```
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
```
- Ne pas tuples travail plus rapidement que les classes de cas? La tâche est complexe, le traitement de grandes quantités de données simple, une sorte d'arithmétique.
- Les Tuples est classes de cas, ne sont-ils pas?
- Les Tuples sont en effet classes de cas de!
- Est-il possible d'ajouter des éléments à res en boucle?
InformationsquelleAutor Steve Gury

Voici une solution qui crée un alias de type et d'une fabrique d'objets.

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 juste de créer une classe de cas.

InformationsquelleAutor retronym

1

Bien que, comme d'autres l'ont dit, explicite (cas) les classes sont les meilleurs dans le sens général.

Cependant pour localiser les scénarios de ce que vous pouvez faire est d'utiliser la tuple extracteur pour améliorer la lisibilité du code:
```
val (first, second) = incrementPair(3, 4)
println(s"$first ... $second")
```
Donné une méthode retournant un n-uplet:
```
def incrementPair(pair: (Int, Int)) : (Int, Int) = {
  val (first, second) = pair
  (first + 1, second + 1)
}
```
InformationsquelleAutor StuartLC

Vous devez vous connecter pour publier un commentaire.