Scala 以通用方式管理trait实例使用者

假设我有以下基本的trait和case类

sealed trait BaseTrait
case class Foo(x: Integer = 1) extends BaseTrait
case class Bar(x: String = "abc") extends BaseTrait

我想为可以处理BaseTrait实例的类创建一个通用接口，如下所示

class FooProcessor(val model: FooModel) extends BaseProcessor[Foo] {
    val v: Option[Foo] = model.baseVar
}
class BarProcessor(val model: BarModel) extends BaseProcessor[Bar] {
    val v: Option[Bar] = model.baseVar
}

class FooModel extends BaseModel[Foo]
class BarModel extends BaseModel[Bar]

为此，我有以下特点

trait BaseModel[T <: BaseTrait] {
    var baseVar: Option[T] = None
}
trait BaseProcessor[T <: BaseTrait] {
    def model: BaseModel[T]
    def process(x: T): Unit = model.baseVar = Option(x)
}

现在让我们想象一下，我的应用程序中有以下处理器

val fooProcessor = new FooProcessor(new FooModel)
val barProcessor = new BarProcessor(new BarModel)

我想用一种比较通用的方式来处理它们，就像这样

def func[T <: BaseTrait](p: T) {
    val c/*: BaseProcessor[_ >: Foo with Bar <: BaseTrait with Product with Serializable]*/ = p match {
        case _: Foo => fooProcessor
        case _: Bar => barProcessor
    c.process(p)
}

class ProcessorContainer {
    implicit val fooProcessor = new FooProcessor(new FooModel)
    implicit val barProcessor = new BarProcessor(new BarModel)
    def func[T <: BaseTrait](p: T) = typedFunc(p)
    private def typedFunc[T <: BaseTrait](p: T)(implicit processor: BaseProcessor[T]) =
        processor.process(p)
}
    
class Test {
    val processorContainer = new ProcessorContainer
    processorContainer.func(Foo())
    processorContainer.func(Bar())
}

我想也可以让编译器相信这两种类型（处理器的T和func参数p的T）是等价的，但这似乎也太过分了（我也不确定如何做到这一点）

因此，我的问题是：是否有可能以一种简单的方式实现我在这里试图实现的目标（以统一的方式管理处理器+每个处理器知道其特定类型的BaseTrait）？有没有一个更好的模式，这是我错过了

更新 正如使控制器隐式解决了这个问题一样，但是如果你想有一个类，在这个类中定义你的控制器+在它的接口上有'func'，编译器似乎不再正确地解决隐式问题。所以如果我试着做这样的事情

def func[T <: BaseTrait](p: T) {
    val c/*: BaseProcessor[_ >: Foo with Bar <: BaseTrait with Product with Serializable]*/ = p match {
        case _: Foo => fooProcessor
        case _: Bar => barProcessor
    c.process(p)
}

class ProcessorContainer {
    implicit val fooProcessor = new FooProcessor(new FooModel)
    implicit val barProcessor = new BarProcessor(new BarModel)
    def func[T <: BaseTrait](p: T) = typedFunc(p)
    private def typedFunc[T <: BaseTrait](p: T)(implicit processor: BaseProcessor[T]) =
        processor.process(p)
}
    
class Test {
    val processorContainer = new ProcessorContainer
    processorContainer.func(Foo())
    processorContainer.func(Bar())
}

类处理器容器{
隐式val fooProcessor=新fooProcessor（新FooModel）
隐式val barProcessor=新barProcessor（新BarModel）
def func[T您可以通过使处理器
隐式
并将它们作为额外参数传递给
func
来创建一个简单的typeclass：

implicit val fooProcessor = new FooProcessor(new FooModel)
implicit val barProcessor = new BarProcessor(new BarModel)

def func[T <: BaseTrait](p: T)(implicit processor: BaseProcessor[T]) =
  processor.process(p)

implicit val fooProcessor=新fooProcessor（新FooModel）
隐式val barProcessor=新barProcessor（新BarModel）
def func[T您可以通过使处理器
隐式
并将它们作为额外参数传递给
func
来创建一个简单的typeclass：

implicit val fooProcessor = new FooProcessor(new FooModel)
implicit val barProcessor = new BarProcessor(new BarModel)

def func[T <: BaseTrait](p: T)(implicit processor: BaseProcessor[T]) =
  processor.process(p)

implicit val fooProcessor=新fooProcessor（新FooModel）
隐式val barProcessor=新barProcessor（新BarModel）
def func[T您的解决方案似乎正是我所需要的，但是，如果在暴露'func'时控制器被封装在类中，则隐式解析似乎没有正确执行。我已更新了我的问题，您是否可以找到解决问题的方法？您的解决方案似乎正是我所需要的，但隐式解析似乎是正确的如果在暴露“func”时控制器被封装在一个类中，则未正确执行。我已更新了我的问题，您是否可以找到解决该问题的方法？