scala - 一元约束到可变参数的 HList

Question

假设我们有这个:

def join[A, B](a: A, b: B)
def join[A, B, C](a: A, b: B, c: C) // etc

基本上有很多用于最多 20 个类型参数的重载方法。

然后是通过对 HList 强制执行一元类型约束来创建 K 列表的以下内容使得所有内部元素的类型都是 Task[_] .

class Test(L <: HList : *->*[Task]#λ](val deps : L = HNil) 

是否可以转换 deps到 Task[A1, A2, A3]等哪里 A1 , A2 , A3是 HList 的内部类型?

因此对于:

val hls = Task(1) :: Task("string") :: Task9(true) :: HNil

检索一个:

Task[(Int, String, Boolean)]

并且对任意数量的参数执行此操作？我可以转换 Task[A], Task[B]到 Task[A, B]对于任何数量的参数，只需要从 HList 获取至 varargs或类似。

Answer 1

从 Scala 的角度来看，那些 join方法除了名称之外没有任何共同点，因此在没有大量样板(或自定义宏)的情况下，在这种情况下不可能真正使用它们。相反，可以使用 join在 Twitter 上的 Future自己反复。你可以通过创建一个新的类型类来做到这一点:

import shapeless._

trait FutureSequence[L <: HList] extends DepFn1[L]

这个类型类将见证一个 hlist L完全由 future 组成，它将为我们提供一种将这些 future 排序为 Future[T] 的方法。 ，其中 T是由 L 中每个 future 内部的类型组成的元组( *->* 给了我们第一部分，但不支持第二部分，甚至不支持任何方便地完成第二部分的方法)。

伴随对象完成所有有趣的工作:

import com.twitter.util.Future
import shapeless.ops.tuple.Prepend

object FutureSequence {
  type Aux[L <: HList, Out0] = FutureSequence[L] { type Out = Out0 }

  implicit def hnilFutureSequence: Aux[HNil, Future[Unit]] =
    new FutureSequence[HNil] {
      type Out = Future[Unit]
      def apply(l: HNil): Future[Unit] = Future.Unit
    }

  implicit def hconsFutureSequence[H, T <: HList, OutT](implicit
    fst: Aux[T, Future[OutT]],
    pre: Prepend[Tuple1[H], OutT]
  ): Aux[Future[H] :: T, Future[pre.Out]] = new FutureSequence[Future[H] :: T] {
    type Out = Future[pre.Out]

    def apply(l: Future[H] :: T): Future[pre.Out] =
      l.head.join(fst(l.tail)).map {
        case (h, t) => pre(Tuple1(h), t)
      }
  }
}

我们在这里使用归纳法——首先我们描述如何排序 HNil (我们的基本情况)，然后我们描述如何排序 Future[H] :: T鉴于我们知道如何排序 T .

接下来，我们将定义一个方法来使其易于使用:

def sequence[L <: HList](l: L)(implicit fs: FutureSequence[L]): fs.Out = fs(l)

然后，如果我们有一些例子:

 val good = Future(1) :: Future("string") :: Future(true) :: HNil
 val bad = Future(1 / 0) :: Future("string") :: Future(true) :: HNil

我们可以对它们进行排序:

scala> import com.twitter.util.Await
import com.twitter.util.Await

scala> Await.result(sequence(good))
res0: (Int, String, Boolean) = (1,string,true)

scala> sequence(bad).onFailure(println)
java.lang.ArithmeticException: / by zero
res1: com.twitter.util.Future[(Int, String, Boolean)] = ...

您还可能需要 FutureSequence类的构造函数中的实例，或类中的特定方法。