Scala composición del tipo de tupla

Question

Teniendo en cuenta un tipo de tupla

type T = (String, Int, String) 

¿Hay alguna manera de poder conseguir un tipo T1, donde T1 sería

type T1 = (MyClass, String, Int, String) 

Me gustaría ser capaz de declarar una clase como

class TupleTypes[T] extends AnotherClass[T1] 

Nota: El tamaño tupla no se conoce y

type T1 = (MyClass, T) 

no devolverá lo que quiero, se devolverá (MyClass, (String, Int, String)) que es diferente.

Gracias

Answer 1

En mi opinión no hay tales construcciones para tuplas, pero Hlist tienen un comportamiento muy similar a la que mostró. Se considera que tienen una estructura de programación tipo avanzada, y el uso puede ser difícil según lo que desee lograr. Aquí hay un excellent starter y un nice implementation.

Answer 2

Puede hacerlo utilizando HList para convertir tuplas de shapeless.

scala> import shapeless._ ; import Tuples._ 
import shapeless._ 
import Tuples._ 

scala> class MyClass ; val m = new MyClass 
defined class MyClass 
m: MyClass = MyClass@3859023a 

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) = (MyClass@3859023a,foo,23,bar) 

Answer 3

tarde a la fiesta, pero en el caso de que usted está buscando una solución "mejor" en lo que se refiere al problema ScalaQuery, intente esto:

1) Crear clase base asignador 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) extiende la base mapper usando objeto de clase de caso/compañero (es decir, no tupla base)

case class Foo (bar: String) 
object Foos extends _Mapper[Foo]("foo") { 
    def foo = column[String]("foo") 
} 

entonces usted puede hacer algo como:

def show: List[Foo] = { 
    val q = (for { f <- Foos } yield f) 

    val foos = db withSession { 
    foos.list map { case t:T => t } 
    } 
    render(foos) 
} 

y tienen un objeto navegable para trabajar con (vs. tupla basada en índices).

Ahora, a veces no desea un gráfico de objeto enorme cuando solo necesita un subconjunto de campos de un grupo de entidades.

Ahí es donde las proyecciones entran, basta con crear una clase de caso que representa el conjunto de campos que desee y, voila, un objeto de proyección navegable para trabajar 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) 
} 

bastante simple, debe ser encapsulado en un DAO con torta, pero el principio general es: tomar la ruta de clase/objeto de caso.

¡Ten en cuenta que ScalaQuery patea increíbles azz, Zeiger es brillante! (como lo son muchos en la comunidad de Scala, el futuro se ve brillante en la forma de Scala ;-))