Scala: Implictly convert a list - scala

Question

Here is a reduced example of what I want to do. The line commented out doesn't compile.
class Animal
object Animal { implicit def toElephant(a: Animal) = a.asInstanceOf[Elephant] }
class Elephant extends Animal
object Main {
def main(args: Array[String]) = {
val a: List[Animal] = List(new Elephant, new Elephant)
// val e: List[Elephant] = a
}
}
In a regular situation, e = a is of course illegal. But with the implicit function, one could think that scala would automatically convert every element in the list.
Is there an elegant way to get this behaviour? If yes, how?
What I wish to know is if there is some obscure corner of scala that can force the behaviour I wish. I am not interested in solutions that add cruft. I can think of them myself. For instance, one could do:
object Animal {
implicit def toElephant(a: Animal) = a.asInstanceOf[Elephant]
implicit def toElephant(a: List[Animal]) = a.asInstanceOf[List[Elephant]] }
and the code above would work.

Answer 1

You can forget implicits and mapping and use simply
val e = a.asInstanceOf[List[Elephant]]
BUT, if you insist, you can of course also do this conversion implicitly. Having an implicit from List[A] to List[B] is no more crufty than an implicit A => B. I wouldn't do this, but if I did I'd generalise it for re-use, importing locally to limit the implicit's scope:
object Implicits {
implicit def AListToBList[A, B <: A](lst: List[A]) = lst.asInstanceOf[List[B]]
}
Then at use-site
import Implicits._
val a: List[Animal] = List(new Elephant, new Elephant)
val e: List[Elephant] = a
e.head.doSomethingElephanty
Be aware of the scope of the import, and stick things within a locally block if necessary.

Answer 2

But with the implicit function, one could think that scala would
automatically convert every element in the list.
Why?
Let's try something:
class X[T : Manifest] {
override def toString = manifest[T].toString
}
val x = new X[Animal]
How will an implicit that converts Animal into Elephant help convert an X[Animal] into an X[Elephant]? There isn't even an instance of Animal to be converted! But let's put an instance there:
class X[T : Manifest](t: T) {
override def toString = manifest[T].toString + t.toString
}
Now we have an instance, but, again, how will Scala convert an X[Animal] into an X[Elephant]? It can't even get at t, because it is private. Let's make it public, then:
class X[T : Manifest](val t: T) {
override def toString = manifest[T].toString + t.toString
}
There, it is public. But how would it be converted? One way would be this:
new X[Elephant](Animal toElephant x.t)
But how would Scala know to do that? Who says that's valid code, or that it is enough?
One could write an implicit teaching X how to convert itself if another implicit conversion is present, and an implicit like that could exist for List, but implicit conversions are dangerous. The less of them there are, the better. And, therefore, such an implicit does not exist.

Answer 3

What about map?
val e = a map {_.asInstanceOf[Elephant]}
or even better:
val e = a collect {case e: Elephant => e}
Note that both asInstanceOf and an implicit conversion for super-type to sub-type is not very ellegant.