A safe way of 'overwriting'/'forcing' a certain implicit resolution - scala

Question

I have a custom formatter (say MyFormat) for org.joda.DateTime which provides a Format[org.joda.DateTime].
Play provides a default formatter for the same class in the play.api.libs.json package.
I would like to use MyFormat across my application, and not the one Play provides. I have done this through explicit imports/mixins which does the trick, however during changes or omissions when these get removed, serialization defaults to the Play formatter and I end up with runtime errors. This seems very error prone.
Ultimately I would like for my code not to compile if there is no MyFormat for org.joda.DateTime in scope whenever one is required.
Is there a nice and safe way of doing this?

Answer 1

You have a couple options, but neither of them will be exactly what you want. The crux of the problem is that Scala will look for implicits within related companion objects. For example, if it needs to find an implicit Format[DateTime], it will look within the companion object of Format and the companion object of DateTime. In this case, there is an implicit def within Format that will produce the desired (or in your case, undesired) Format[DateTime] and there's nothing you can do to get rid of it, short of forking and hacking Play.
Workaround 1: Create an object with your custom formatters, and import it globally:
package my.project
object Formats {
implicit val dateTimeFormat: Format[DateTime] = ???
}
(in other files)
import my.project.Formats._
The Format[DateTime] imported into a local scope will supersede the one resolved from the Format object. However, you can't prevent your code from compiling without it (unless you have some sort of scalastyle rule or something that requires the import).
Workaround 2: Create a wrapper for DateTime with it's own Format, and give it an implicit conversion to DateTime.
case class MyDateTime(dt: DateTime) {
implicit def toDateTime: DateTime = dt
}
object MyDateTime {
implicit val fmt: Format[MyDateTime] = ???
implicit def fromDateTime(dt: DateTime): MyDateTime = MyDateTime(dt)
}
This is not a complete example, but an idea as to how to implement this. DateTime can be swapped with MyDateTime is most places, however it may require other implicits revolving around MyDateTime. For example, when I tried using this with Anorm, I needed an implicit ToStatement[MyDateTime], and probably a few others--so that's the obvious disadvantage. However, this would explicitly avoid using the default Format[DateTime].