Can't access extra methods of trait implementation - scala

Question

Please take a look at the following example:
trait MyTrait {
def myTraitMeth : String
}
object TraitImplementation extends MyTrait {
def myTraitMeth = "Works fine"
def myExtraMeth = "Doesn't work"
}
case object Manager {
def returnImplementation : MyTrait = TraitImplementation
}
println(Manager.returnImplementation.myExtraMeth)
In this scenario, what is happening is that I can't access the extra method of the trait implementation, TraitImplementation, because I defined the return method of the method returnImplementation to be of the type MyTrait - I cannot change this condition.
An obvious solution would be enforcing this extra method on the trait, but that is not an option for me, given the fact that other implementations of the MyTrait cannot have such a method.
What I really need is to make sure that the method returnImplementation will return something that is an implementation of MyTrait, and, at the same time, allow the caller of that method to use all methods that have been implemented, not only those enforced on the trait.
I tried messing around with types, going with something like
case object Manager {
def returnImplementation [A <: MyTrait] : A = TraitImplementation
}
but this leads to a type mismatch, because the compiler cannot understand that A is a generic type.
Any ideas on how to accomplish it?

Answer 1

I originally wanted to leave this as a comment, but there was a discussion going on so that the space was getting kind of crowded. I decided to write it up as an answer instead.
This problem you have sounds like something you would get around by using case matching. When returnImplementation returns a trait of type MyTrait, case match on it to get the desired subclass, and depending on which subclass it is, have different behavior. Wrap it in an Option if you want monadic fail-fast behavior, so that only certain subclass will trigger the creation of some result. The result will be Some(...) if the desired subclass with the desired method was found, None otherwise.
trait MyTrait {
def myTraitMeth : String
}
object TraitImplementation extends MyTrait {
def myTraitMeth = "Works fine"
def myExtraMeth = "Doesn't work"
}
case object Manager {
def returnImplementation : MyTrait = TraitImplementation
}
For your println statement, you would call it like so:
Manager.returnImplementation match {
case TraitImplementation => println(TraitImplementation.myExtraMeth)
case _ =>
}
If you want to keep your code purely functional with no side-effects like println functions, do the following:
val result = Manager.returnImplementation match {
case TraitImplementation => Some(TraitImplementation)
case _ => None
}
result will be of type Option[TraitImplementation] and you can pass it around for context dependent behavior.
If you have side effecting code, like your println statement, you can isolate it from the rest of your purely function code by calling foreach on this Option like so:
result.foreach(x => println(x.myExtraMeth))
Based on the discussion Luis and you had, you can also case match on MyExtTrait for the desired behavior.
trait MyExtTrait {
def myExtraMeth: String
}
val result = Manager.returnImplementation match {
case x: MyExtTrait => println(x.myExtraMeth)
case _ =>
}
or
val result = Manager.returnImplementation match {
case x: MyExtTrait => Some(x)
case _ => None
}
result.foreach(x => println(x.myExtraMeth))