隐式调用时找不到 CanBuildFrom

Question

考虑以下 REPL 会话：

@ def test[C[X] <: TraversableOnce[X]](implicit cbf: CanBuildFrom[C[Int], Int, C[Int]]) = cbf()
defined function test

@ test[List]
res32: collection.mutable.Builder[Int, List[Int]] = ListBuffer()

@ def test[C[X] <: TraversableOnce[X]] = implicitly[CanBuildFrom[C[Int], Int, C[Int]]]
cmd33.sc:1: Cannot construct a collection of type C[Int] with elements of type Int based on a collection of type C[Int].
def test[C[X] <: TraversableOnce[X]] = implicitly[CanBuildFrom[C[Int], Int, C[Int]]]
                                                 ^
Compilation Failed

test 函数的第一个定义编译并工作，而第二个不编译。它们之间的唯一区别是CanBuildFrom 实例的获取方式。在第一种情况下，它被声明为隐式参数，要求编译器找到一个。在第二种情况下，它是通过 implicitly 函数调用的，理论上，它在隐式搜索范围方面的行为应该相同。是什么导致了这种行为？

Answer 1

implicitly（在Predef中）的定义是：

def implicitly[A](implicit ev: A): A = A

它只是向您显式地显示了一个隐含的已经在范围内（在使用站点）。

现在当你写这个时：

import collection.generic.CanBuildFrom

def test[C[X] <: TraversableOnce[X]]
  (implicit cbf: CanBuildFrom[C[Int], Int, C[Int]]) = ???

您要求调用者提供隐式（在调用站点）。

当你写作时

def test[C[X] <: TraversableOnce[X]] = 
  implicitly[CanBuildFrom[C[Int], Int, C[Int]]]

您通过调用implicitly 要求编译器查找一个隐式已经在作用域内。 但你在范围内没有任何给定类型的隐含！所以test 的两个定义正在做一些完全不同的事情。

您通常使用implicitly 来获取您没有名称的隐式，因为它是使用上下文边界或类型类表示法指定的，例如def test[A: TypeClass]。您不能在此处使用该符号，因为CanBuildFrom 具有三个类型参数，而不是一个。所以你不能在这里使用implicitly。

您可以在第一个案例中使用implicitly：

def test[C[X] <: TraversableOnce[X]]
  (implicit cbf: CanBuildFrom[C[Int], Int, C[Int]]) = {

  implicit val onceAgain = implicitly[CanBuildFrom[C[Int], Int, C[Int]]]
  assert(onceAgain == cbf)
}

但是你已经知道你有那个隐含的名字cbf...

---

请注意，您可以获取已知集合类型的隐式 CanBuildFrom：

implicitly[CanBuildFrom[List[Int], Int, List[Int]]]  // works!

但如果您的集合类型 (C[X]) 是抽象的，这将不起作用。