scala - HList的证据保全LUB约束

Question

我想我需要一个HList，它必须被约束为使其所有元素都是某种类型的子类型。 LUBConstraint似乎是我想要的，并且确实确实限制了这样的HList的构造-但我看不到如何再次获取证据，因此我可以进行映射(实际上是遍历，因为它必须是一元的)在HList上，并在每个元素上调用一个方法(存在于LUB类型中)。

另外，我希望遍历操作产生的HList的类型与输入HList的类型完全相同。

用例是一种功能性的“监听器列表”-HList的所有元素都是“监听器”，必须将其通知“事件”，接受或拒绝它们，并以更新的“内部状态”返回自身的新版本。 。如果这是我所需要的，那么我可以使用一个普通的不可变Scala集合。但我也希望直接输入单个元素而不使用asInstanceOf-因此尝试使用HList的动机。

Answer 1

通常，如果您要对HList中的所有元素执行某些操作，则需要在HList上映射一个多态函数值。例如，假设我具有以下设置:

trait Listener[L <: Listener[L]] {
  def handle(s: String): Option[L]
}

class FooListener extends Listener[FooListener] {
  def handle(s: String) =
    if (s.size == 3) Some(this) else None
}

class BarListener extends Listener[BarListener ]{
  def handle(s: String) = Some(this)
}

import shapeless._

val listeners = new FooListener :: new BarListener :: HNil

现在，我想向每个这些监听器发送一个 String并收集结果。如果我只想发送一个固定值，这将很容易:

object event123 extends Poly1 {
  implicit def listener[L <: Listener[L]] = at[L](_.handle("123"))
}

val result = listeners.map(event123)

可以将其适本地键入为 Option[FooListener] :: Option[BarListener] :: HNil。如果我使用的是 shapeless-contrib，则可以对这个 HList进行排序:

import scalaz._, Scalaz._, shapeless.contrib.scalaz._

val sequenced: Option[FooListener :: BarListener :: HNil] = sequence(result)

或者只是使用 traverse:

traverse(listeners)(event123)

不幸的是，如何定义多态函数值存在限制，这意味着部分应用程序不方便，因此，如果我们不知道在编译时要发送的 String，则情况会更加复杂:

object event extends Poly1 {
  implicit def listener[L <: Listener[L]] = at[(L, String)] {
    case (listener, string) => listener.handle(string)
  }
}

traverse(listeners.zip(listeners.mapConst("123")))(event)

我们在其中用字符串压缩了元素，然后映射了一个多态函数，该函数将元组存储在结果上。还有其他方法可以使用或多或少相同的方法来执行此操作，但是没有一个方法非常清楚。

完全不同的方法是跳过多态函数值并定义一个新的类型类:

trait Notifiable[L <: HList] {
  def tell(s: String)(l: L): Option[L]
}

object Notifiable {
  implicit val hnilNotifiable: Notifiable[HNil] = new Notifiable[HNil] {
    def tell(s: String)(l: HNil) = Some(HNil)
  }

  implicit def hconsNotifiable[H <: Listener[H], T <: HList](implicit
    tn: Notifiable[T]
  ): Notifiable[H :: T] = new Notifiable[H :: T] {
    def tell(s: String)(l: H :: T) = for {
      h <- l.head.handle(s)
      t <- tn.tell(s)(l.tail)
    } yield h :: t
  }
}

def tell[L <: HList: Notifiable](s: String)(l: L) =
  implicitly[Notifiable[L]].tell(s)(l)

然后:

val sequenced: Option[FooListener :: BarListener :: HNil] =
  tell("123")(listeners)

这不太通用(它仅适用于 Option，不适用于任意应用程序)，但是它不需要额外的顺序依赖性，而且由于怪异的局限性，可以说它比跳过箍部分地应用多态函数值要少一些困惑的编译器。