scala - 您如何使用 Scala 将功能混合到迭代过程的每一步？

我正在 Scala 中进行优化程序，并且正在寻找有关如何构建我的问题的建议。该过程一次执行一个步骤，因此我天真地使用 Step 类对问题进行了建模:

class Step(val state:State) {
  def doSomething = ...
  def doSomethingElse = ...
  def next:Step = ... // produces the next step in the procedure
}

过程中的每一步都由不可变的 Step 类表示，该类的构造函数被赋予上一步生成的状态，并且其 next 方法生成后续的 Step 实例。基本思想是用 Iterator[Step] 包装它，以便可以采取步骤直到优化收敛。虽然有点简单，但这适用于 Vanilla 情况。

但是，现在我需要为算法添加各种扩展，并且需要根据要优化的问题任意混合这些扩展。通常这将通过可堆叠特征模式来完成，但这种方法会为这个问题带来问题。这是两个可能的扩展的示例:

trait FeatureA extends Step {
  // Extension-specific state passed from step to step
  val aState:FeatureAState = ...

  // Wrap base methods to extend functionality
  abstract override def doSomething = { ...; super.doSomething(); ... }
}

// Just like Feature A
trait FeatureB extends Step {
  val bState:FeatureBState = ...
  abstract override def doSomething = { ...; super.doSomething(); ... }
}

有时优化需要混合 FeatureA ，有时需要 FeatureB ，有时两者都需要。

主要问题是基类的 next 方法不知道混合了哪些扩展，因此后续生成的步骤不会将任何扩展混合到初始步骤中。

此外，每个扩展都需要一步一步地传递自己的状态。在这个例子中，FeatureAState/FeatureBState 实例包含在它们各自的特征中，但是如果不覆盖 next 方法，FeatureA 和 FeatureB 就无法传递它们的唯一状态。无法覆盖每个特征中的 next ，因为可能混合了这些扩展的组合，并且每个扩展都只知道自己。

所以似乎我已经把自己画到了一个角落里，我希望有人对如何用 Scala 解决这个问题有一些见解。哪种设计模式最适合此类问题？

最佳答案

您可能对探索 F-bound polymorphism 模式感兴趣。此模式允许您定义返回特征或基类中当前子类型的方法。这是您示例的简化版本:

trait Step[T <: Step[T]] { self: T =>
    val name: String
    def next: T
}

case class BasicStep(name: String) extends Step[BasicStep] {
    def next = this.copy(name = name + "I")
}

case class AdvancedStep(baseName: String, iteration: Int) extends Step[AdvancedStep] {
    val name = s"$baseName($iteration)"
    def advancedFunction = println("foobar")
    def next = this.copy(iteration = iteration + 1)
}

所以我们已经定义了基本的 Step trait，它有一个 name 和一个 next 方法，它返回扩展类的任何自我类型。例如， next 中的 BasicStep 方法返回一个 BasicStep 。这允许我们根据需要迭代和使用特定于子类型的覆盖:

val basicSteps = Iterator.iterate(BasicStep("basic"))(_.next).take(3).toList
//basicSteps: List[BasicStep] = List(BasicStep(basic), BasicStep(basicI), BasicStep(basicII))

val advancedSteps = Iterator.iterate(AdvancedStep("advanced", 0))(_.next).take(3).toList
//advancedSteps: List[AdvancedStep] = List(AdvancedStep(advanced,0), AdvancedStep(advanced,1), AdvancedStep(advanced,2))
val names = advancedSteps.map(_.name)
//names: List[String] = List(advanced(0), advanced(1), advanced(2))
advancedSteps.last.advancedFunction
//foobar

如果你想像这样混合多种类型，不幸的是你不能使用泛型(你会收到“继承不同类型的特征实例”错误)。但是，您可以使用抽象类型成员来表达 F-bound 多态性:

trait Step { self =>
    type Self <: Step { type Self = self.Self }
    val name: String
    def next: Self
}

trait Foo extends Step {
    val fooMarker = "foo"
}
trait Bar extends Step {
    val barMarker = "bar"
}

case class FooBar(name: String) extends Foo with Bar {
    override type Self = FooBar
    def next = this.copy(name + "I")
}

然后 FooBar 实例将具有 Foo 和 Bar 上的方法:

val fooBar = FooBar("foobar").next.next
fooBar.barMarker //"bar"
fooBar.fooMarker //"foo"
fooBar.name //"fooNameII"

请注意，该名称来自 Foo ，因为它首先被混入。

关于scala - 您如何使用 Scala 将功能混合到迭代过程的每一步？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/31195627/