scala - Would you use a type class in this case? -

suppose i've got adt this:

sealed trait extends product serializable object {   case class a1() extends   case class a2() extends   case class a3() extends   case class a4() extends } 

suppose have trait afoo that:

type foo = ... trait afoo { def asfoo(a: a): foo } 

now need provide 2 different implementations afoo. writing that:

abstract class afoosupport extends afoo {    protected def asfoo1(a1: a1): foo   protected def asfoo2(a2: a2): foo   protected def asfoo3(a3: a3): foo   protected def asfoo4(a4: a4): foo    def asfoo(a: a) = match {     case a1: a1 => asfoo1(a1)     case a2: a2 => asfoo2(a2)     case a3: a3 => asfoo3(a3)     case a4: a4 => asfoo4(a4)   } }   class afoo1 extends afoosupport {    // implement asfoo1, asfoo2, asfoo3, asfoo4 }  class afoo2 extends afoosupport {    // implement asfoo1, asfoo2, asfoo3, asfoo4 } 

this approach work wonder if there better way it. use type class in case ?

there 1 function (a => foo) concrete classes different implementations. don't see here big advantage of using type class. start considering type class when 1 of arguments generic.

as suggested in comments 1 extract pattern matching fold

def fold[f](a: a)(f1: a1 => f, ..., f4: a4 => f): f = match {     case a1: a1 => f1(a1)     ... } 

and implement required functions:

def afoo(a: a): foo = fold(a)(afoo1, afoo2, afoo3, afoo4) def afoo1(a: a1): foo = ...  ... def afoo4(a: a4): foo = ...  def bfoo(a: a): foo = fold(a)(bfoo1, bfoo2, bfoo3, bfoo4) ... def bfoo4(a: a4): foo = ... 

but afoosupport sort of fold implemented using inheritance instead of composition.