Scala：泛型类型的隐式证据

Question

Assume there are such two traits:

trait Fooer[-T] {
  def foo(x: T): Unit
}

trait CanFoo[-T] {
  def fooer: Fooer[T]
}

And a function:

def bar[T: CanFoo](x: T) = {
  implicitly[CanFoo[T]].fooer.foo(x)
}

Everything works so far. However, I was stuck when trying to make bar work recursively on collection types like Seq[T] (ie bar[Seq[T]](seq) recursively calls bar[T] on seq 's elements). I can't do implicit object CanFooSeq extends CanFoo[Seq[_]] since that would cause the type information of the elements to be lost. (I also tried to make another function def bar[T: CanFoo](seq: Seq[T]) = ... , but that didn't solve the problem either since Seq[T] still isn't being recognized as a Foo-able type.)

Is there any way to solve this problem?

Answer 1

implicit def CanFooSeq[T]: CanFoo[Seq[T]] = new CanFoo[Seq[T]] { def fooer = ... }

(if you want to have it only in case you have CanFoo[T] , add the implicit parameter: implicit def CanFooSeq[T: CanFoo]: CanFoo[Seq[T]] = new CanFoo[Seq[T]] { def fooer = ... } ) if I understood the question correctly. Note it has to be a def , because objects and vals can't have type parameters, so a new one will be created on each call (which is very unlikely to matter for performance in practice).