在Scala中，如何使用隐式转换将方法“添加”到公共父类的子类？

Question

Let's say I have some data in "dumb" models. In this example, I'll use Circle and Triangle , which extend a trait Shape .

I'm looking for a way to isolate behavior that could use these shapes, but I'm not sure the best way to structure it. If I'm trying to draw these shapes onto a document, I'd want to be able to write code that looked like this:

shapes.foreach(doc.add)

The trick here is that shapes is Seq[Shape] , and the add method is something I want to add implicitly since I can't modify the shapes themselves (nor would I want to bake this specific functionality into them).

Where I'm getting stuck is, I don't know how to mix implicit conversions with the subclasses. See QUESTION: below in the code for more info.

// Let's assume I'm working with some shape models that are defined in some
// external library that's out of my control.
sealed trait Shape
case class Circle() extends Shape
case class Triangle() extends Shape

// Now I'm building an add that adds stuff to a Document
// and I want to locally implement methods that work on these general shapes.
case class Document()

// Using implicit conversion to add methods to a case class that's just holding data
implicit class DocumentExtensions(doc: Document) {
  // I don't want this to be called
  def add(shape: Shape): Unit = println("Add a shape")

  // I want to use shape-specific methods
  def add(shape: Circle): Unit = println("Add a circle")
  def add(shape: Triangle): Unit = println("Add a triangle")
}

val doc = Document()
val shapes = Seq(Circle(), Triangle())

// This just prints "Add a shape" for the Circle and Triangle.
// I want to it to print "Add a circle" and "Add a triangle".
shapes.foreach { shape =>
  // QUESTION:
  // Is there a way or pattern to have this call the add for the
  // subclass instead of for Shape? I want this to be fully dynamic
  // so that I don't have to list out each subclass. Even more ideally,
  // the compiler could warn me if there was a subclass that there wasn't
  // an implicit add for.
  doc.add(shape)
}

// This would work, but I'm wondering if there's a way to do this more
// dynamically without listing everything out.
shapes.foreach {
  case c: Circle => doc.add(c)
  case t: Triangle => doc.add(t)
}

I'm sure there's a name for what I'm looking for, but I just don't know what it is or what to search for.

Answer 1

Problem: compiler cannot choose and use an implicit value specific to handle a subclass. It's basically impossible to decide what method to call (for Triangle or Circle ) when you only know that it's a Shape . This is actually a classical problem, which has standard solutions.

Solution 1

Pattern matching inside DocumentExtension.add

Pros:

1. Since your trait Shape is defined as sealed , compiler will you if you miss a case for a certain ancestor.
2. Separation of class definition and action handling

Cons:

1. Boilerplate required to list all subclasses of your trait

Solution 2

Classical Visitor pattern

sealed trait Shape {
  def addToDoc(doc: Document, visitor: ShapeDrawer)
}
final class Triangle extends Shape {
  def addToDoc(doc: Document, visitor: ShapeDrawer) = visitor.draw(doc, this)
}
final class Circle extends Shape {
  def addToDoc(doc: Document, visitor: ShapeDrawer) = visitor.draw(doc, this)
}

trait ShapeDrawer {
  def draw(doc: Document, t: Circle)
  def draw(doc: Document, t: Triangle)
}

val drawer: ShapeDrawer = ???
val doc: Document = ???
val shapes = Seq.empty[Shape]

shapes.foreach(_.addToDoc(doc, drawer))

This solution also matches the requirement of being sure at compile time that you've handled every subclass of Shape, but requires adding strange methods to the trait itself.