Scala隐式委派与继承

Question

Salutations, SO!

I'm obviously some species of a scala noob. I was intrigued from the beginning by the possibility to express those tedious delegations via implicits and thought it was cool to use them throughout .

My issue is that type tests no longer worked as they would with inheritance. See bellow code, 'false' is printed 4 times (unsurprinsingly)

trait T { def bar = Unit }
class A { def aFoo() = print("AFooooo") }
class B { def bFoo() = print("BFooooo") }

object Ca { implicit def delToA(me : Ca) : A = me.a}
class Ca(val a : A) extends T { }

object Cb { implicit def delToB(me : Cb) : B = me.b}
class Cb(val b : B) extends T { }

object MyName extends App {
  val ca : T = new Ca(new A)
  val cb : T = new Cb(new B)

  println(ca.isInstanceOf[A])
  println(ca.isInstanceOf[B])

  println( cb.isInstanceOf[A])
  println(cb.isInstanceOf[B])
}

Is thee any way to be able to test that a T is either an A or a B underneath? And a way to bind it to an A or a B variable, of course. Another way, not inheritance.

And.. is there some obvious reason why false is always the result of isInstanceOf? The code could have very well resulted in : true false false true.

Answer 1

Type tests like isInstanceOf will not use implicit conversions to try to convert to the type you're testing it against. When you say ca.isInstanceOf[A] , ca must be an instance of A in order to be true . ca and cb are not instances of A or B , so all tests should return false as expected.

This is because implicits are resolved at compile time, but isInstanceOf as checked a runtime. There's no way we can mix the two like that.

You can use a compile-time check to see that something can be implicitly viewable as something else.

implicit class Wrapper[A](a: A) {
    def isImplicitly[B](implicit ev: A => B): Boolean = true
}

class Y
class Z

implicit def z2y(z: Z): Y = new Y

val y = new Y
val z = new Z

scala> z.isImplicitly[Y]
res66: Boolean = true

scala> y.isImplicitly[Z]
<console>:39: error: No implicit view available from Y => Z.
              y.isImplicitly[Z]
                            ^

But this is fundamentally different as it doesn't really return true/false, it just fails to compile if it's not true. And it still wouldn't work for your example. Since ca is a T , the compiler wouldn't even try to implicitly convert from T => A because the conversion is defined for Ca => A . It wouldn't know at compile time that Ca is a Ca , nor which companion object to find the required implicit in.