How can I hide my implicit method or disable `LabelledGeneric` for a specific sealed family?

Question

I have to use third-party traits which are designed as:

trait Super[T]
trait Sub[T] extends Super[T]

and I have defined the following method to provide instances for arbitrary sealed families:

implicit def subFor[T, Repr](
  implicit
  gen: LabelledGeneric.Aux[T, Repr],
  sg: Lazy[JsonFormat[Repr]]
): Sub[T] = ???

but somewhere else in the code, somebody has already defined

implicit def superFor[T]: Super[T] = ???

for some specific types, e.g. Option and a few others.

Actually, I'd like to use the existing implementations instead of using my subFor generic implementation. However, because my method returns Sub[T] and the existing implementation returns Super[T] I can't see any way to define my implementation in such a way that it is considered lower priority.

How can I block my subFor from being called for specific types? Is there some way to disable LabelledGeneric for specific types, or some priority reducing mechanism that would stop the compiler from ever looking for my subFor if it already sees a Super[T]?

The old [ambiguous implicits trick](http://stackoverflow.com/a/15983103/334519) should work here. — Travis Brown, Apr 21 '15 at 19:35
@TravisBrown awesome! Is there a canonical shapeless `Not[T]` that I should use? — fommil, Apr 21 '15 at 20:05
I don't think so—there's type inequality (implemented this way), but IIRC not type class negation. — Travis Brown, Apr 21 '15 at 20:15

score 2 · Answer 1 · answered Apr 21 '15 at 20:55

If the implicit defs are defined in companion objects, you have to resort to collision-based type computations. But for "some specific types", the defs are usually not in companion objects of the class (e.g. not on object Option). In this case, you can take advantage of the fact that implicits hide each other within a given namespace. So you can just

implicit def superFor[T]: SomeThrowawayType = ???

and their superFor won't work any more. Since you change the return type, it won't collide or anything; it's effectively just gone. Then you can create your own forwarders at whatever priority level you want that explicitly call their defs.

This does require, however, that you import your stuff after theirs (so it shadows theirs). If this seems too fiddly to be relied upon, you'll have to go for the type computation.

How can I hide my implicit method or disable `LabelledGeneric` for a specific sealed family?

1 Answers1