如何对所有具有上下文绑定的类进行模式匹配

Question

I have a type class and a few instances:

trait TC[T] { def doThings(x: T): Unit }
implicit val tcA = new TC[A] { /* ... */}
implicit val tcB = new TC[B] { /* ... */}
implicit val tcC = new TC[C] { /* ... */}
/* ... */

In my call site, I have input as Any, and I need to check if there is an implicit for the input actual type:

def process(in: Any) = in match {
  case x: A => implicitly[TC[A]].doThings(x)
  case x: B => implicitly[TC[B]].doThings(x)
  case x: C => implicitly[TC[C]].doThings(x)
  //...
}

This seems tedious and unnecessary, as I have to list all the classes that have this type class instance. Can I achieve this by something like:

def process(in: Any) = in match {
  case x: T : TC => implicitly[TC[T]].doThings(x) //This does not work
}

---

Edit: input is an Any (an Object from a Java library). Cannot use generic or context bound on the input.

Answer 1

You need to ask for an implicit TC , Any won't work. As follows:

trait TC[T] { def doThings(x: T): Unit }

implicit def tcS: TC[String] = new TC[String] {
  override def doThings(x: String): Unit = println("string")
}

implicit def tcI: TC[Int] = new TC[Int] {
  override def doThings(x: Int): Unit = println("int")
}

def process[T : TC](x: T): Unit = implicitly[TC[T]].doThings(x)

process("")
process(1)
// process(4L) wont compile

Try it out!

Answer 2

If you really want to do what you have mentioned in your question, you can write it as below, but if you just want to call doThings by finding an implicit instance of appropriate TC - refer João Guitana answer

object Main extends App {
  class A
  class B
  class C

  trait TC[T] { def doThings(x: T): Unit }
  implicit val tcA = new TC[A] {
    override def doThings(x: A): Unit = println("From A")
  }
  implicit val tcB = new TC[B] {
    override def doThings(x: B): Unit = println("From B")
  }
  implicit val tcC = new TC[C] {
    override def doThings(x: C): Unit = println("From C")
  }

  def process[T: ClassTag](in: T) = in match {
    case x: A => implicitly[TC[A]].doThings(x)
    case x: B => implicitly[TC[B]].doThings(x)
    case x: C => implicitly[TC[C]].doThings(x)
  }

  process(new A())
  process(new B())
  process(new C())

}
/* === Output ====
From A
From B
From C
*/