How to implement subtype resolution of typeclass in scala

Question

I want to understand how to go about implementing the following use-case using typeclasses in Scala (or find out if it is even possible).

Given a sealed trait and a couple of concrete cases:

sealed trait Base
case class Impl1() extends Base
case class Impl2() extends Base

Given a typeclass operating on Base and an instance for each of the corresponding base implementations:

trait Processor[B <: Base]:
   def process(b: B): String

given Processor[Impl1] with:
   def process(b: Impl1): String = ??? // not important

given Processor[Impl2] with:
   def process(b: Impl2): String = ??? // not important

Given a list of base objects:

val objects: List[Base] = ??? // whatever

Is it possible to implement a method that goes something like this?

val processed = objects.map(obj => process(obj))

def process[B <: Base](b: B)(using proc: Processor[B]) = proc.process(b)

When I try to naively implement the above as-such, the compiler complains that it can't find an implicit for Processor[Base], which I guess it makes sense, since in the context of the method call for process(obj), the obj val has the Base type.

What I would like to do is to let the compiler figure out the concrete type of obj, fetch the corresponding given instance for the concrete type and inject it into the process method. Is it even possible to do such a thing? Does it even make sense?

(Note - I've written my code in scala 3, but I'll gladly accept an answer in scala 2 syntax).

Answer 1

With a list of base objects you won't be able to do it, the list doesn't contain the real type at compile time and the compiler won't be able to find their respective type classes.

In scala 3 the typed list is the tuple, so you can use a tuple to have a typed list and obtain what you are expecting. The method you need is and adaptation of the one you can find with the same name in the scala 3 documentation and is simple as:

inline def summonAll[T <: Tuple](tup: T): List[String] =
  inline tup match
    case _: EmptyTuple => Nil
    case tupl: (t *: ts) => summonInline[Processor[t]].process(tupl.head) :: summonAll[ts](tupl.tail)

and you can use it only passing the list of elements you want to obtain in a tuple in the expected type:

summonAll[(A, B)]

Here you can see the following full code running:

import scala.compiletime.{erasedValue, summonInline}

trait Processor[A]:
  def process(t: A): String

object Processor:
  def apply[T: Processor]: Processor[T] = summon[Processor[T]]

  given Processor[String] with
    def process(t: String): String = "im String: " + t

  given Processor[Int] with
    def process(t: Int): String = "im Int: " + t

inline def summonAll[T <: Tuple](tup: T): List[String] =
  inline tup match
    case _: EmptyTuple => Nil
    case tupl: (t *: ts) => summonInline[Processor[t]].process(tupl.head) :: summonAll[ts](tupl.tail)

val t1 = ("hi", "bye", 44 )

val t2 = summonAll(t1)

println(t2) //List(im String: hi, im String: bye, im Int: 44)

Answer 2

With this particular typeclass you can easily create the Processor[Base] which the compiler asks for:

given Processor[Base] with:
   def process(b: Base): String = b match
     case b: Impl1 => process(b)
     case b: Impl2 => process(b)

Using type class derivation you can also generate it automatically, but I am afraid it's going to be far more code! And if you enable warnings (which you should), the compiler should warn you about a non-exhaustive match if a new subclass is added anyway. So I'd use this manual version unless you have quite a lot of subclasses to handle in your actual case or they change often.

Note "this particular typeclass" it wouldn't work e.g. if process took more than 1 B parameter, or some parameters with more complex types containing B.