Dato un tipo Tuplescala tipo tupla composizione
type T = (String, Int, String)
C'è un modo posso ottenere un tipo T1, dove T1 sarebbe
type T1 = (MyClass, String, Int, String)
mi piacerebbe essere in grado di dichiarare una classe come
class TupleTypes[T] extends AnotherClass[T1]
Nota: La dimensione tupla non è nota e
non restituirà quello che voglio, verrà restituito (MyClass, (String, Int, String)) che è diverso.
Grazie
A mio parere non ci sono tali costrutti per tuple, ma HList hanno un comportamento molto simile a quello che avete mostrato. Sono considerati dotati di una struttura di programmazione di tipo avanzato e l'utilizzo può essere difficile a seconda di ciò che si desidera ottenere. Ecco uno excellent starter e uno nice implementation.
È possibile eseguire questa operazione utilizzando lo HList per la conversione di tuple da shapeless.
scala> import shapeless._ ; import Tuples._
import shapeless._
import Tuples._
scala> class MyClass ; val m = new MyClass
defined class MyClass
m: MyClass = [email protected]
scala> val t1 = ("foo", 23, "bar")
t1: (String, Int, String) = (foo,23,bar)
scala> val t2 = (m :: t1.hlisted) tupled
t2: (MyClass, String, Int, String) = ([email protected],foo,23,bar)
in ritardo alla festa, ma nel caso in cui si sta cercando una soluzione "migliore" per quanto riguarda il problema ScalaQuery, provate questo:
1) creare classe base mapper con ID
import org.scalaquery.ql.extended.{ExtendedTable => Table}
abstract class Mapper[T](table: String) extends Table[T](None, table) {
def id = column[Int]("id", O PrimaryKey)
}
2) estendere base mappatore usando caso classe/guidata oggetto (cioè non tupla base)
case class Foo (bar: String)
object Foos extends _Mapper[Foo]("foo") {
def foo = column[String]("foo")
}
allora si può fare qualcosa di simile:
def show: List[Foo] = {
val q = (for { f <- Foos } yield f)
val foos = db withSession {
foos.list map { case t:T => t }
}
render(foos)
}
e hanno un oggetto navigabile con cui lavorare (vs. tupla basata su indice).
Ora, a volte non si desidera un grafico di oggetto enorme quando è necessario solo un sottoinsieme di campi da un gruppo di entità.
Ecco dove le proiezioni entrare, basta creare una classe case che rappresenta l'insieme di campi che si desidera e, voilà, un oggetto di proiezione navigabile per lavorare con:
case class Yum (foo: String, baz: String)
def show: List[Yum] = {
val q = (for { f <- Foos; b <- Bars; if f.id is b.fooID } yield (f.foo, b.baz))
val yums = db withSession {
yums.list map { case t:T => t }
}
render(yums)
}
abbastanza semplice, devono essere passate tra un DAO guidato dalla torta, ma il principio generale è: prendi la strada caso/percorso oggetto.
Si noti che ScalaQuery calcia incredibili azz, Zeiger è geniale! (come lo sono molti nella comunità di Scala, il futuro è alla moda in Scala ;-))
Grazie Miles, molto interessante. La domanda è: come ottengo il tipo di t2 e lo uso per una definizione di classe? Come nell'esempio sopra 'classe TupleTypes [T] estende AnotherClass [T1]' c'è comunque per ottenere il T1? – mericano1
Potresti fornirmi alcuni esempi delle forme generali dei membri che prevedi di aggiungere a 'TupleTypes' e' AnotherClass'. E potresti anche dire se hai bisogno che ci sia una qualche relazione utile tra 'T' e' T1' (cioè devi essere in grado di costruire un valore di tipo 'T1' dato i valori di tipi' MyClass' e 'T' e/o viceversa)? –
Ciao Miles, apprezzo il tuo aiuto. Sto lavorando con scalaquery e voglio creare una classe base astratta che abbia una colonna di tipo Long (id). Quindi 'TupleTypes [T]' è in realtà 'BaseTable [T]'. Altre classi che estendono 'BaseTable [T]' avranno una lista di colonne e il tipo 'T' sarà una tupla come' (String, Int, Boolean, Date) '. Ora perché il mio 'BaseClass [T]' deve estendere la tabella scalaquery e fornire una tupla con tutti i tipi di colonna, 'T1' dovrà essere' (Long, String, Int, Boolean, Date) '. Spero che questo spieghi cosa sto cercando di ottenere. – mericano1