Question

我正在研究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]包装它，因此可以采取步骤直到优化收敛。虽然有点简单，但这适用于香草案例。

但是，现在我需要为算法添加各种扩展，我需要根据优化的问题随意混合这些扩展。通常这将通过可堆叠的特征模式来实现，但是这种方法对此问题提出了问题。以下是两个可能扩展的示例：

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来解决这个问题。哪种设计模式最适合此类问题？

Answer 1

您可能有兴趣探索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特征，它有一个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绑定的多态性：

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的迭代过程的每个步骤混合使用？

1 个答案: