Scala：从泛型类型到第二个泛型类型的隐式转换

假设我有两组类，第一组继承自Foo，第二组继承自Bar

class Foo
class Baz extends Foo
class Bar
class Qux extends Bar

我想创建一个通用的隐式转换函数，在给定范围内有隐式转换器类型的情况下，将任何Foo转换为Bar

trait Converter[A <: Foo, B <: Bar] {
  def convert(a : A) : B
}

implicit object BazToQuxConverter extends Converter[Baz, Qux] {
  def convert(a : Baz) : Qux = new Qux
}

implicit def FooToBar[A <: Foo, B <: Bar](a : A)(implicit converter : Converter[A, B]) : B = converter.convert(a)

…我得到以下错误：

<console>:17: error: type mismatch;
 found   : Baz
 required: Qux
       val b : Qux = a
                     ^

---

这将很好地编译，但它将在运行时崩溃，因为

Qux

（converter.convert（a））的结果不能强制转换为

Qax

（

作为[Qax]

的替代）。理想情况下，我希望它能够在编译时捕获上述行，因为范围内没有任何

转换器[Bax，Qax]

。

这是一个在2.11中修复的错误。看起来它已经被修复了，因为相关的票证是

trait Converter[A <: Foo, B <: Bar] {
  def convert(a : A) : B
}

implicit object BazToQuxConverter extends Converter[Baz, Qux] {
  def convert(a : Baz) : Qux = new Qux
}

implicit def FooToBar[A <: Foo, B <: Bar](a : A)(implicit converter : Converter[A, B]) : B = converter.convert(a)

欢迎使用Scala版本2.11.0-20131030-090728-c38235fd44（OpenJDK 64位服务器虚拟机，Java 1.7.045）。
键入要计算的表达式。
键入：有关详细信息的帮助。
scala>：粘贴
//进入粘贴模式（按ctrl-D键完成）
福班
类Baz扩展了Foo
分类栏
类Qux扩展条
特性转换器[A你能看一下吗：这看起来像是一个非常相似的线程，线程似乎是关于将转换链接在一起，我的问题只是关于两个泛型类型之间的隐式转换。不确定该线程中的任何内容如何适用于我的问题。很糟糕，我遇到了Scala bug，但很高兴知道它已经修复。我不知道2.10中是否有解决方案。。。
implicit def BadFooToBar[A <: Foo, B <: Bar](a : A)(implicit converter : Converter[A, _]) : B = converter.convert(a).asInstanceOf[B]

class Qax extends Bar
val a : Baz = new Baz
val b : Qax = a

Welcome to Scala version 2.11.0-20131030-090728-c38235fd44 (OpenJDK 64-Bit Server VM, Java 1.7.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

scala> :paste
// Entering paste mode (ctrl-D to finish)

  class Foo
  class Baz extends Foo
  class Bar
  class Qux extends Bar

  trait Converter[A <: Foo, B <: Bar] {
    def convert(a : A) : B
  }

  implicit object BazToQuxConverter extends Converter[Baz, Qux] {
    def convert(a : Baz) : Qux = new Qux
  }

  import scala.language.implicitConversions
  implicit def FooToBar[A <: Foo, B <: Bar](a : A)(implicit converter : Converter[A, B]) : B = converter.convert(a)

  val a : Baz = new Baz
  val b : Qux = a

// Exiting paste mode, now interpreting.

defined class Foo
defined class Baz
defined class Bar
defined class Qux
defined trait Converter
defined object BazToQuxConverter
import scala.language.implicitConversions
FooToBar: [A <: Foo, B <: Bar](a: A)(implicit converter: Converter[A,B])B
a: Baz = Baz@4f4db2ac
b: Qux = Qux@760d62e0