How to select an object at runtime - Scala - scala

Question

I need to select an object implementation based on the generics passed. Here is a small example of what I want
import scala.reflect.runtime.universe.{TypeTag,typeOf}
trait Animal27
{
val name: String
val sound: String
}
case class Tiger27(name:String, sound: String) extends Animal27
object Tiger27
{
def AbilityEvolve(tiger27 : Tiger27) : String =
{
tiger27.name + " is a tigher and she has increased attack"
}
}
case class Cheetah27(name:String,sound:String) extends Animal27
object Cheetah27
{
def AbilityEvolve(cheetah27: Cheetah27): String =
{
cheetah27.name + "is a cheethah and he has increased speed"
}
}
class World[A: TypeTag] {
def getMyObject =
{
if (typeOf[A] =:= typeOf[Cheetah27])
Cheetah27
else
Tiger27
}
def Evolve : String =
{
getMyObject.AbilityEvolve + " hence evolved" // how do i perform
//getMyObject.AbilityEvolve
}
}
object App27 extends App{
val world = new World[Cheetah27]
println(world.Evolve)
}
May I know how to dynamically select the object based on the generic used. That is how to make sure that getMyObject.AbilityEvolve is able to call the respective object's method?
Thanks

Answer 1

The ideal solution would be to make all of the possible return types inherit from some common trait. So if you needed to select between FirstObject and SecondObject which both have a foo method, define a HasFoo trait and have both objects mix in that trait.
trait HasFoo {
def foo(): Unit
}
object FirstObject extends HasFoo {
def foo() = { println("FirstObject") }
}
object SecondObject extends HasFoo {
def foo() = { println("SecondObject") }
}
object WithTraits {
def decideAtRuntime(x: Boolean): HasFoo =
if (x) FirstObject else SecondObject
}
The benefit to this is that it's efficient. The JVM runtime was built to do polymorphism like this, and it's clear to the reader as well. If you don't have control over the objects which are being returned, you can always use implicits to add support for the new trait.
However, perhaps your return type is too generic, or there is some other extenuating circumstance. In that case, there is another way. Scala supports what's known as structural typing. That is, you can define a type (not a class; there is a difference) which contains exactly all of the objects that have a foo method.
object FirstObject {
def foo() = { println("FirstObject") }
}
object SecondObject {
def foo() = { println("SecondObject") }
}
object WithStructure {
def decideAtRuntime(x: Boolean): { def foo(): Unit } =
if (x) FirstObject else SecondObject
}
Note the return type of decideAtRuntime. It's not a class name but { def foo(): Unit }. This is a structural type for any object that has a method foo which takes zero arguments and returns nothing.
Structural types are still typesafe, as Scala's compiler will verify that the methods do in fact exist at compile-time. However, it compiles down to JVM instructions that use the Object class and reflection. This means that if a Java API tries to interface with it, the Java API may not be typesafe. It also means that, because of the way the reflection API works, every call to decideAtRuntime will slow your program down.