由一元类型构造函数限制的非一元类型构造函数

Question

标题试图描述以下子类型

implicitly[Map[Int, String] <:< Iterable[(Int, String)]]

---

类型参数A在这里推断为(Int, String)

def foo[A](cc: Iterable[A]): A = cc.head
lazy val e: (Int, String) = foo(Map.empty[Int, String])

但是尝试使用类型参数边界来实现类似的效果，我能做的最好的事情就是像这样显式指定类型构造函数的数量

def foo[F[x,y] <: Iterable[(x,y)], A, B](cc: F[A, B]): (A, B) = cc.head
lazy val e: (Int, String) = foo(Map.empty[Int, String])

因为以下错误

def foo[F[x] <: Iterable[x], A](cc: F[A]) = cc.head
lazy val e: (Int, String) = foo(Map.empty[Int, String])
// type mismatch;
// [error]  found   : A
// [error]  required: (Int, String)
// [error]   lazy val e: (Int, String) = foo(Map.empty[Int, String])
// [error]                                  ^

因此使用Iterable 作为上限，我们似乎需要一个签名来处理一元类型构造函数Seq 和Set，以及一个单独的签名来处理二元类型构造函数Map

def foo[F[x] <: Iterable[x], A](cc: F[A]): A                  // When F is Seq or Set
def foo[F[x,y] <: Iterable[(x,y)], A, B](cc: F[A, B]): (A, B) // When F is Map

有没有一种方法可以使用适用于所有三个的类型边界来获得单个签名？换一种说法，我们如何编写一个适用于所有集合的扩展方法？

Answer 1

我认为这里的问题是F 设置为Map，善良是错误的。你不得不说：我有一些类型X，它扩展了F[A]，所以当我向上转换它时，我可以将它用作F[A] - 这反过来我们想成为Iterable [A的子类型]。如果我们这样问，听起来很难。

这就是为什么我个人会留在：

@ def foo[A](x: Iterable[A]): A = x.head
defined function foo

@ foo(List(1 -> "test"))
res24: (Int, String) = (1, "test")

@ foo(Map(1 -> "test"))
res25: (Int, String) = (1, "test")

“给我任何x，它是Iterable[A] 的实例A”。

如果我必须做一些推导......我可能也会走这条路。我认为这个限制是CanBuildFrom 工作方式的原因 - 为部分类型提供匹配很困难，尤其是在 Map 这样的情况下，所以让我们一次提供整个类型作为参数，以限制推理的数量需要。