Posso nominare una tupla (definire una struttura?) In Scala 2.8?

Question

Non mi sembra molto utile ripetere sempre una definizione di tuple lungo tutta la linea ogni volta che ne ho bisogno. Posso solo nominarlo e usare come nome del tipo? Sarebbe bello per citarne i suoi campi anche invece di utilizzare ._1, ._2 ecc

Answer 1

Per quanto riguarda la prima domanda, si può semplicemente utilizzare un tipo di alias:

type KeyValue = (Int, String) 

E, naturalmente, Scala è un object-oriented di lingua, in modo per quanto riguarda il secondo su come specializzare una tupla, la parola magica è eredità:

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

Questo è tutto. La classe non ha nemmeno bisogno di un corpo.

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

Si noti, tuttavia, che eredita da classi case (che Tuple2 è), è deprecato e potrebbe essere annullato in futuro. Ecco il compilatore di avviso che si ottiene per la definizione della classe di cui sopra:

avvertimento: caso classe class KV ha cassa classe antenata class Tuple2. Questo è stato deprecato per complicare indebitamente sia l'utilizzo che l'implementazione. Dovresti invece usare gli estrattori per la corrispondenza dei modelli sui nodi non foglia.

Answer 2

L'alias di tipo va bene per denominare la Tupla, ma provare invece a utilizzare una classe di caso. Sarete in grado di utilizzare i parametri denominati

Esempio con parametri:

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

Con una classe case:

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

Ecco una soluzione che crea un tipo di alias e un oggetto di fabbrica.

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) 

Tuttavia, come altri hanno già detto, probabilmente dovresti creare una classe di caso.

Answer 4

Sebbene, come altri hanno già detto, le classi (caso) esplicite sono le migliori in senso generale.

Tuttavia per gli scenari localizzate quello che si può fare è quello di utilizzare il tuple extractor per migliorare la leggibilità del codice:

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

Dato un metodo che restituisce una tupla:

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