scala typ krotka skład

Question

Biorąc pod uwagę rodzaj Tuple

type T = (String, Int, String) 

Czy jest jakiś sposób mogę uzyskać typu T1, gdzie T1 będzie

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

chciałbym być w stanie zadeklarować klasę jak

class TupleTypes[T] extends AnotherClass[T1] 

Note: wielkość krotka nie jest znana i

type T1 = (MyClass, T) 

nie zwróci tego, co chcę, zwróci (MyClass, (String, Int, String)), który jest inny.

Dzięki

Answer 1

Moim zdaniem nie istnieją takie konstrukty za krotki, ale HList mieć zachowanie bardzo podobną do tej, którą widać. Uważa się, że ma zaawansowaną strukturę programowania typów, a użycie może być trudne w zależności od tego, co chcesz osiągnąć. Oto excellent starter i nice implementation.

Answer 2

Możesz to zrobić, korzystając z HList, aby kumulować konwersje z 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

późno do partii, ale w przypadku, gdy poszukują „lepsze” rozwiązania w odniesieniu do problemu ScalaQuery, spróbuj tego:

1) utworzyć klasę bazową odwzorowujący z 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) rozciągają odwzorowujący podstawy użyciu klasy przypadku/towarzyszący obiektu (to znaczy nie jest krotką oparciu)

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

następnie można zrobić coś takiego:

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

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

i mają żeglownych obiekt do pracy z (vs. krotka oparta na indeksie).

Teraz czasami nie potrzebujesz ogromnego wykresu obiektów, gdy potrzebujesz tylko podzestawu pól z grupy obiektów.

To gdzie projekcje przyjść, wystarczy utworzyć klasę case, który reprezentuje zestaw pól, które chcesz i voila, do nawigacji obiekt projekcja do pracy z:

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) 
} 

dość prosta, powinna być zawarta w ciasto DAO napędzane ciastem, ale ogólna zasada brzmi: weź ścieżkę klasy/obiektu.

Należy pamiętać, że ScalaQuery kopie niewiarygodny azz, Zeiger jest genialny! (jak wielu w społeczności Scala, przyszłość wygląda jasno na Scala ;-))