Question

考虑在Schala采用以下代码:

object Test {
  class A {}

  class B extends A {}

  class AI extends A {
    def sayHello: String = "Hello from AI"
  }

  implicit def AtoAI(a: A): AI = a

  class BI extends B {
    def sayHello: String = "Hello from BI"
  }

  implicit def BtoBI(b: B): BI = b

  def main(args: Array[String]) {
    val a = new A
    println(a.sayHello)

    val b = new B
    println(b.sayHello)
  }
}

使用含蓄物导致成形法。事实上,拆分物显示,产生转换方法的只有goto 0。内部:

public Test$AI AtoAI(Test$A);
  Code:
   0:   goto    0

public Test$BI BtoBI(Test$B);
  Code:
   0:   goto    0

What causes that behaviour? I understand, that a hierarchy of classes here is a suspect, but implicit conversion should be applied only once.

I use Scala 2.9.1

Answer 1

不是冰,但我肯定不会把它称作ug。

oil底

class A

class B

implicit def aToB(a: A) : B = a

双方无需以任何方式进行转换。暗含的只是同书写一样的。

implicit def aToB(a: A): B = aToB(a)

由于汇编者插入<代码>aToB 为将结果代码改为规定返回类型<代码>而发出的呼吁 B。

<代码>goto 0 执行只是尾声优化。汇编者可能会发出警告,因为它会产生一种以这种方式开始的方法。

也许可以有一项规则,即不以暗含的方法在自己的身体中提供。但它并不总是造成一种无限的 lo。

implicit def listAToListB(l: list[A] = l match {
  case Nil => Nil
  case x:xs => toB(x) :: xs // equivalent to toB(x) :: listAToList[B](xs)
}

(ok this is just a map(toB)). Anyway the same could happen with two mutually recursive implicits. In my opinion, it s not worthwhile to tweak the spec just to avoid some possibility to write an infinite, do nothing loop, among many others. But a warning when such a loop is detected, irrespective of implicits, would be nice.

Answer 2

我无法理解,为什么法典完全编纂。我核实它确实汇编了。 tn t 你不得不在暗中转换方法中下台?

Didier points out, that the implicit conversion gets applied recursively, which means the code can compile without a downcast.

下面的法典增加了降水量(should,不改变操作时间的行为)。失败时,它失败了。 www.un.org/Depts/DGACM/index_french.htm 正如迪迪耶所说,明文的降播阻止了在这里重新适用默示转换。

object Test {
  class A {}

  class B extends A {}

  class AI extends A {
    def sayHello: String = "Hello from AI"
  }

  implicit def AtoAI(a: A): AI = a.asInstanceOf[AI]

  class BI extends B {
    def sayHello: String = "Hello from BI"
  }

  implicit def BtoBI(b: B): BI = b.asInstanceOf[BI]

  def main(args: Array[String]) {
    val a = new A
    println(a.sayHello)

    val b = new B
    println(b.sayHello)
  }
}

www.un.org/Depts/DGACM/index_french.htm A, 即无这种方法。显然,这会造成工作瘫痪。发生的情况没有说明;就你而言,这是一种无限的循环。

友情链接