Scala - 如何定义逆变 class 的工厂方法？

Question

I have a trait with common parameters for a data source, with case classes for each actual source

trait AbstractSource {
  val name: String
}

case class ConcreteSource(name: String) extends AbstractSource

I also have a trait for a class which acts on this data source (contravariant for the source)

trait AbstractConsumer[-T <: AbstractSource] {
  def foo(inp: T): Unit
}

class ConcreteConsumer extends AbstractConsumer[ConcreteSource] {
  override def foo(inp: ConcreteSource): Unit =
    println(inp.name)
}

I want to create a factory method for my pipeline method which creates the correct consumer based on the input data source. I have tried the following but both have errors

object ConsumerFactory {
  def create(inp: AbstractSource): AbstractConsumer[_ <: AbstractSource] =
    inp match {
      case _: ConcreteSource => new ConcreteConsumer()
      case _ => ???
    }
    
  def createTwo[T <: AbstractSource](inp: T): AbstractConsumer[T] =
    inp match {
      case _: ConcreteSource => new ConcreteConsumer() // errors "required: AbstractConsumer[T], found: ConcreteConsumer"
      case _ => ???
    }
}

class Main {
  def pipeline[T <: AbstractSource](consumer: AbstractConsumer[T], source: T): Unit =
    consumer.foo(source)

  def execute(): Unit = {
    val consumer: ConcreteSource = ConcreteSource("john")

    val source = ConsumerFactory.create(consumer) // errors "found: AbstractConsumer[_$1] where type _$1 <: AbstractSource, required: AbstractConsumer[ConcreteSource]"
    val source = ConsumerFactory.createTwo(consumer)

    pipeline(source, consumer)
  }
}

val x = new Main()
x.execute()

If I understand correctly, the issue is that I need to supply a subtype of AbstractConsumer[T] to the pipeline, but I don't know how to do this based on the input due to the contravariant type parameter.

Answer 1

IMHO, theese kinds of problems are more easily solvable with a typeclass, like this:

trait AbstractConsumer[-S <: AbstractSource] {
  def consume(inp: S): Unit
}
object AbstractConsumer {
  sealed trait ConsumerFactory[S <: AbstractSource] {
    type Consumer <: AbstractConsumer[S]
    
    def createConsumer(): Consumer
  }
  
  type Factory[S <: AbstractSource, C <: AbstractConsumer[S]] = ConsumerFactory[S] { type Consumer = C }
  object Factory {
    def apply[S <: AbstractSource, C <: AbstractConsumer[S]](factory: => C): Factory[S, C] =
      new ConsumerFactory[S] {
        override final type Consumer = C
        
        override final def createConsumer(): Consumer =
          factory
      }
  }
  
  // Get by type.
  def apply[S <: AbstractSource](implicit factory: ConsumerFactory[S]): factory.Consumer =
    factory.createConsumer()

  // Get by value.
  def fromSource[S <: AbstractSource](source: S)(implicit factory: ConsumerFactory[S]): factory.Consumer =
    factory.createConsumer()
}

Then the concrete source will implement the typeclass, like this:

final class ConcreteConsumer extends AbstractConsumer[ConcreteSource] {
  override def consume(inp: ConcreteSource): Unit =
    println(inp.name)
}
object ConcreteConsumer {
  implicit final val ConcreteConsumerFactory: AbstractConsumer.Factory[ConcreteSource, ConcreteConsumer] =
    AbstractConsumer.Factory(new ConcreteConsumer())
}

And, finally, you can use it like this:

import ConcreteConsumer._ // Put the factory in scope.

val source = new ConcreteSource("john")

val consumer1 = AbstractConsumer[ConcreteSource]
val consumer2 = AbstractConsumer.fromSource(source)

You may adapt the code if the factory needs some arguments or something.

---

The code can be seen running here .