Question

我们有一个特性，其中包含execute[T <: Record](Seq[(Session) => T]): Seq[T]方法，其中Record是我们从数据库中检索的所有特征的超级

trait DbTrait {
  val threadCount: Int
  val db: Database
  protected def getGroupSize(size: Int, threadCount: Int) {
    (size / threadCount) + if(size % threadCount == 0) 0 else 1
  }
  def execute[T <: Record](funs: Seq[(Session) => T]): Seq[T]
}

trait DbTraitSingle extends DbTrait {
  val threadCount = 1
  def execute[T <: Record](funs: Seq[(Session) => T]): Seq[T] =
    db.withSession{session: Session => funs.map(f => f(session))}
}

trait DbTraitMulti extends DbTrait {
  val threadCount = 4
  def execute[T <: Record](funs: Seq[(Session) => T): Seq[T] =
    funs.grouped(getGroupSize(funs.size, threadCount)).map(funs => Future {
      db.withSession{session: Session => funs.map(f => f(session))}
    }.toList.flatten
}

等等。理想情况下，我们希望能够创建像

这样的东西

def executePoly2[T1 <: Record, T2 <: Record]
  (tuple: Tuple2[(Session) => T1, (Session) => T2]): Tuple2[T1, T2]

对于任意元组（即executePoly3，executePoly4等），但有两个问题：

有没有办法在这里减少样板量，或者我们会不会创建22种不同的方法签名？
是否有一种类型安全的方法来分割类似于seq.grouped方法调用的元组，或者我们是否遇到了所有不同threadCount值的特殊情况（目前还没有' t超过4）？

Answer 1

使用Miles Sabin的Shapeless库，您可以轻松使用。看看他们可以用Tuple做些什么。特别是在arity上抽象。

 import syntax.std.tuple._
 import poly._

 var myProducedTuple = myTuple map (_(session))

将元组划分为多个元组的类型安全方法

1 个答案: