不可变类的多态更新

Question

我一直试图解决这个问题，但我似乎无法找到解决这个问题的方法。我似乎无法在 Scala 中正确建模。

假设我有一个 trait MyTrait 和一些不可变的类来实现它。

它看起来像这样：

trait MyTrait {
  type Repr <: MyTrait

  def substitute(original: Item, replacement: Item) : Repr

  def substituteAll(
    originals: List[Item],
    replacement: Item
  ) : Repr = {
    originals match {
      case head :: tail => substitute(head).substituteAll(tail, replacement)
      case Nil => this //this complains that this is not of type Repr
    }     
  }
}

trait MyTrait2 { ... }

case class MyClassA(originals: List[Item])
extends MyTrait with MyTrait2 {
  type Repr = MyClassA

  def substitute(original: Item, replacement: Item) : MyClassA = {
    //whatever code that updates the list etc. 

    MyClassA(newOriginals)
  }    
}

case class MyClassB(originals: List[Item])
extends MyTrait with MyTrait2 {
  type Repr = MyClassB

  def substitute(original: Item, replacement: Item) : MyClassB = {
    //whatever code that updates the list etc. 

    MyClassB(newOriginals)
  }    
}

case class CompoundClass(list : List[MyTrait with MyTrait2])
extends MyTrait {
  type Repr = CompoundClass

  def substitute(
    original: Item,
    replacement: Item
  ) : CompoundClass = 
    CompoundClass(list.map(
      myClass => myClass.substitute(original, replacement)
    ))
  )
  //the above complains that it is expecting
  // List[MyTrait with MyTrait2]
  //while in fact it is getting MyTrait2#Repr
}

如果我要总结我的问题，它们会如下：

• 通过 super-trait 的方法更新不可变类应该返回与实现类相同的类型。

• Super-trait 需要能够在有意义的时候返回 this，而不是返回另一个对象。我似乎对此有疑问。

• 我需要能够在不知道实际类型的情况下将超级特征传递给函数。标准多态性。这样该函数就可以调用 trait 的方法，而无需 了解实际的具体类型。

• 我需要能够使用组合将类组合成其他类。 （想象一个由子表达式组成的表达式）。这似乎是标准组合，但在上述情况下，#Repr

出现了这些错误

我最初尝试在MyTrait[T] 中使用泛型类型，但这使得无法传递我想要的任何具体类。我现在正在尝试使用抽象类型，我似乎在编译时面临同样的问题。本质上我认为现在真的没有区别，我又陷入了同样的陷阱。

我做错了什么？我看错了吗？

Answer 1

这里有一些问题，其中一些与多态性完全无关！

从substituteAll 方法开始：

trait MyTrait {
  type Repr <: MyTrait

  def substitute(original: Item, replacement: Item) : Repr

  def substituteAll(
    originals: List[Item],
    replacements: List[Item]
  ) : Repr = {
    originals match {
      case head :: tail => substitute(head).substituteAll(tail)
      case Nil => this
    }     
  }
}

substitute 和 substituteAll 都接受两个参数，但您试图用一个参数调用它们。这永远行不通！

您还有一个问题是编译器没有证据表明this 是Repr。第一个问题可以很容易地解决，方法是将两个输入压缩到一个元组列表中，然后使用内部函数，第二个问题可以通过手动提供证据来解决：

trait MyTrait {
  type Repr <: MyTrait

  def substitute(original: Item, replacement: Item) : Repr

  def substituteAll(
    originals: List[Item],
    replacements: List[Item]
  )(implicit typed: this.type => Repr) : Repr = {
    def loop(pairs: List[(Item, Item)]): Repr = pairs match {
      case (orig, rep) :: tail =>
        substitute(orig, rep)
        loop(tail)
      case Nil => typed(this) //this complains that this is not of type Repr
    }
    loop(originals zip replacements)
  }
}

您的下一个问题是 Repr 类型参数不包含您希望它为复合类型 MyTrait with MyTrait2 保留的内容。

这不是一个完整的类型，因为Repr 参数仍然是抽象的。你真正想要的是完全指定的类型MyTrait with MyTrait2 { type Repr = MyTrait with MyTrait2 }

鉴于这有点麻烦，引入另一个特征来表示它会更容易：

trait CompoundElem extends MyTrait with MyTrait2 {
  type Repr <: CompoundElem
}

然后您可以在其余代码中使用它：

case class MyClassA(originals: List[Item]) extends CompoundElem {
  type Repr = MyClassA

  def substitute(original: Item, replacement: Item) : MyClassA = {
    val newOriginals = originals
    MyClassA(newOriginals)
  }
}

case class MyClassB(originals: List[Item]) extends CompoundElem {
  type Repr = MyClassB

  def substitute(original: Item, replacement: Item) : MyClassB = {
    val newOriginals = originals
    MyClassB(newOriginals)
  }
}

case class CompoundClass(list : List[CompoundElem]) extends MyTrait {
  type Repr = CompoundClass

  def substitute(
    original: Item,
    replacement: Item
  ) = CompoundClass(
   list.map( _.substitute(original, replacement) )
  )  
}

如果你想让元素类型保持更长时间，也可以编写最后一个类：

object MyTrait {
  //type alias helper to view the type member as though it were a param
  //A neat trick, shamelessly borrowed from the shapeless library
  type Aux[R] = MyTrait { type Repr = R }
}

case class CompoundClass[E <: MyTrait.Aux[E]](list : List[E]) extends MyTrait {
  type Repr = CompoundClass[E]

  def substitute(
    original: Item,
    replacement: Item
  ) = CompoundClass(
    list.map( _.substitute(original, replacement) )
  )  
}

以这种方式编写，您在大多数情况下也不需要中间特征。例如，包含ClassA 列表的CompoundClass 就可以正常工作。

如果你想要一个 List 和 ClassA 和 ClassB 的组合，那么你仍然需要中间体来帮助编译器准确解开 Repr 应该是什么，它无法计算ClassA with ClassB 的 Repr 也应该是 ClassA with ClassB。

如果您不介意完全擦除元素类型，您可以这样做：

case class CompoundClass(list : List[MyTrait]) extends MyTrait {
  type Repr = CompoundClass     
  def substitute(
    original: Item,
    replacement: Item
  ) = CompoundClass(
    list.map( _.substitute(original, replacement) )
  )
}

它只是MyTraits 中的CompoundClass，当你拉取元素以将它们视为ClassA 或ClassB 或MyTrait2 时，你需要使用模式匹配，但你赢了'不需要任何中间特征。

---

最后...作为参考，这是使用 F-Bounds 重新实现的相同想法。请注意类型参数如何允许self type，因此您无需在所有子类中显式定义Repr：

trait Item {}

trait MyTrait {
  type Repr <: MyTrait

  def substitute(original: Item, replacement: Item) : Repr  
  def substituteAll(originals: List[Item], replacements: List[Item]) : Repr
}

object MyTrait {
  trait Aux[T <: MyTrait.Aux[T]] extends MyTrait { self: T =>
    type Repr = T

    def substituteAll(originals: List[Item], replacements: List[Item]) : T = {
      def loop(pairs: List[(Item, Item)]): Repr = pairs match {
        case (orig, rep) :: tail =>
          substitute(orig, rep)
          loop(tail)
        case Nil => this
      }
      loop(originals zip replacements)
    }
  }
}

trait MyTrait2 { }

case class MyClassA(originals: List[Item]) extends MyTrait.Aux[MyClassA] with MyTrait2 {
  def substitute(original: Item, replacement: Item) = MyClassA(originals)
}

case class MyClassB(originals: List[Item]) extends MyTrait.Aux[MyClassB] with MyTrait2 {
  def substitute(original: Item, replacement: Item) = MyClassB(originals)
}

case class CompoundClass(list : List[MyTrait]) extends MyTrait.Aux[CompoundClass] {
  def substitute(
    original: Item,
    replacement: Item
  ) = CompoundClass(
    list.map( _.substitute(original, replacement) )
  )
}