Simplify convoluted code with implicits - scala

Question

I am writing a piece of code which I feel has become very convoluted.
I have a API which accepts an argument which is a trait. This trait can be implemented by many types. Furthermore, each of these classes need to be handled by a specialized processor.
For example, I have created a Trait below called Context which has two actual types of MobileContext and WebContext.
let's say that the MobileContext and WebContext are logged differently and we have specialized implementations in the form of ContextWriter[MobileContext] and ContextWriter[WebContext].
The requirement is that the method should be generic, but it should be able to dispatch the call to the right ContextWriter depending on the actual type of the trait.
Here is my code.
trait Context
case class WebContext(name: String) extends Context
case class MobileContext(name: String) extends Context
trait ContextWriter[T] {
def log(message: String, context: T) : Unit
}
object ContextWriterUtil {
def log[T](message: String, context: T)(implicit writer: ContextWriter[T]) = {
writer.log(message, context)
}
}
object ContextWriterImplicits {
implicit val webImpl = new ContextWriter[WebContext] {
override def log(message: String, context: WebContext) = println(s"I am in web context ${context} and the message is ${message}")
}
implicit val mobileImpl = new ContextWriter[MobileContext] {
override def log(message: String, context: MobileContext) = println(s"I am in mobile context ${context} and the message is ${message}")
}
implicit val baseImpl = new ContextWriter[Context] {
override def log(message: String, context: Context) = context match {
case s: WebContext => {
val writer = implicitly[ContextWriter[WebContext]]
writer.log(message, s)
}
case s: MobileContext => {
val writer = implicitly[ContextWriter[MobileContext]]
writer.log(message, s)
}
case _ => throw new Exception("don't understand this type")
}
}
}
import ContextWriterImplicits._
object MyApplication extends App {
// this is the generic method.
def call[T <: Context](message: String)(implicit context: T) = {
val actualContext = implicitly[Context]
ContextWriterUtil.log(message, actualContext)
}
def web() = {
implicit val webContext = WebContext("web")
call("I am calling the method")
}
def mobile() = {
implicit val mobileContext = MobileContext("mobile")
call("I am calling the method")
}
web()
mobile()
}
This works. But I feel its too verbose and unwieldy. I want to write this in a cleaner way.

Answer 1

TLDR: Remove inheritance from your code.
I don't see why you would need baseImpl: ContextWriter[Context], just delete this implicit and always ask for the more precise context. call becomes:
def call[T: ContextWriter](message: String)(implicit context: T) = {
ContextWriterUtil.log(message, context)
}
For that to work you need to update web and mobile to explicitly specify the type parameter. Even if there is a single instantiation of this type parameter that make the code compile, scalac is not able to figure that out:
def web() = {
implicit val webContext = WebContext("web")
call[WebContext]("I am calling the method")
}
def mobile() = {
implicit val mobileContext = MobileContext("mobile")
call[MobileContext]("I am calling the method")
}
You might be able to get ride of the explicit typing by combining Context and ContextWriter into a single implicit. For example, why not take an ìmplicit ContextWriter argument when you instanciate your Context, and be done with it?