Question

我正在使用Shapeless并使用以下方法计算两个HLists之间的区别：

  def diff[H <: HList](lst1: H, lst2:H):List[String] = (lst1, lst2) match {
    case (HNil, HNil)                 => List()
    case (h1::t1, h2::t2) if h1 != h2 => s"$h1 -> $h2" :: diff(t1, t2)
    case (h1::t1, h2::t2)             => diff(t1, t2)
    case _                            => throw new RuntimeException("something went very wrong")
  }

由于该方法的两个参数都采用H，我希望不同类型的HLists不能在这里编译。例如：

diff("a" :: HNil, 1 :: 2 :: HNil)

不应该编译，但确实如此，它会产生运行时错误：java.lang.RuntimeException: something went very wrong。我可以对类型参数做些什么来使这个方法只接受具有相同类型的两个边？

Answer 1

其他答案没有真正解决的一件事是，这完全是一个类型推断问题，可以通过简单地将参数列表分成两部分来解决：

def diff[H <: HList](lst1: H)(lst2: H): List[String] = (lst1, lst2) match {
  case (HNil, HNil)                 => List()
  case (h1::t1, h2::t2) if h1 != h2 => s"$h1 -> $h2" :: diff(t1)(t2)
  case (h1::t1, h2::t2)             => diff(t1)(t2)
  case _                            => throw new RuntimeException("bad!")
}

这给了我们想要的东西：

scala> diff("a" :: HNil)(1 :: 2 :: HNil)
<console>:15: error: type mismatch;
 found   : shapeless.::[Int,shapeless.::[Int,shapeless.HNil]]
 required: shapeless.::[String,shapeless.HNil]
       diff("a" :: HNil)(1 :: 2 :: HNil)
                           ^

这是有效的（即不能不恰当地编译然后在运行时爆炸）因为Scala的方法类型推断基于每个参数列表工作。如果lst1和lst2位于相同的参数列表中，则H将被推断为最低上限，这通常不是您想要的。

如果您将lst1和lst2放在单独的参数列表中，则编译器会在看到H后立即决定lst1。如果lst2的类型不同，那就会爆炸（这就是我们的目标）。

你仍然可以通过明确地将H设置为HList来解决这个问题，但我担心这是你自己的想法。

Answer 2

不幸的是，基本HList特征是未参数化的，因此在您的方法调用中H刚解析为Hlist（这确实是任何Hlist的超类型，无论如何具体元素类型）。要解决这个问题，我们必须稍微改变定义，而是依赖于通用类型约束：

def diff[H1 <: HList, H2 <: HList](lst1: H1, lst2: H2)(implicit e: H1 =:= H2): List[String] = (lst1, lst2) match {
  case (HNil, HNil)                 => List()
  case (h1::t1, h2::t2) if h1 != h2 => s"$h1 -> $h2" :: diff(t1, t2)
  case (h1::t1, h2::t2)             => diff(t1, t2)
  case _                            => throw new RuntimeException("something went very wrong")
}

我们来看看：

scala> diff("a" :: HNil, 1 :: 2 :: HNil)
<console>:12: error: Cannot prove that shapeless.::[String,shapeless.HNil] =:= shapeless.::[Int,shapeless.::[Int,shapele
              diff("a" :: HNil, 1 :: 2 :: HNil)
                  ^

scala> diff("a" :: HNil, "b" :: HNil)
res5: List[String] = List(a -> b)

scala> diff("a" :: 1 :: HNil, "b" :: 2 :: HNil)
res6: List[String] = List(a -> b, 1 -> 2)

现在我们仍然可以“作弊”并明确地将H1和H2设置为HList，然后我们又回到原点。

scala> diff[HList, HList]("a" :: HNil, 1 :: 2 :: HNil)
java.lang.RuntimeException: something went very wrong
  at .diff(<console>:15)
  at .diff(<console>:13)

不幸的是，我不认为这很容易解决（当然可以，但我没有快速解决方案）。

Answer 3

我可以提供更严格的变体，不能用显式类型参数欺骗。

object diff {
    class Differ[T <: HList](val diff: (T, T) => List[String])

    def apply[T <: HList](l1: T, l2: T)(implicit differ: Differ[T]): List[String] = differ.diff(l1, l2)

    implicit object NilDiff extends Differ[HNil]((_, _) => Nil)

    implicit def ConsDiff[H, T <: HList : Differ] = new Differ[H :: T]({
      case (h1 :: t1, h2 :: t2) if h1 != h2 => s"$h1 -> $h2" :: diff(t1, t2)
      case (h1 :: t1, h2 :: t2) => diff(t1, t2)
    })
  }

它肯定比上面的复杂得多，并且我尝试使用Polymorphic function，但无法以正确的递归编译结束。

无形HList类型检查

3 个答案: