Scala：基于参数类型的混入

Question

我有一组模型类别和一组可应用于这些模型上的算法。并非每种模型都能执行所有算法。我希望模型类别能够声明它们可以执行哪些算法。模型能够执行的算法可能取决于其参数。

例如：假设我有两个算法MCMC和Importance，它们被表示为traits：

trait MCMC extends Model {
  def propose...
}

trait Importance extends Model {
  def forward...
}

我有一个模型类Normal，它接受一个mean参数，这个参数本身也是一个Model。现在，如果mean实现了MCMC，我希望Normal也实现MCMC，如果mean实现了Importance，我希望Normal也实现Importance。

我可以这样写： class Normal(mean: Model) extends Model { // 共同的部分放在这里 }

class NormalMCMC(mean: MCMC) extends Normal(mean) with MCMC {
  def propose...implementation goes here
}

class NormalImportance(mean: Importance) extends Normal(mean) with Importance {
  def forward...implementation goes here
}

我可以创建工厂方法，以确保使用给定的均值创建正确类型的Normal。但是显而易见的问题是，如果mean同时实现了MCMC和Importance怎么办？那么我希望Normal也能同时实现它们两个。但我不想创建一个重新实现propose和forward的新类。如果NormalMCMC和NormalImportance没有参数，我可以将它们变成traits并进行混合。但是在这里，我希望混入取决于参数的类型。有好的解决方案吗？

- Avi Pfeffer

Answer 1

使用self types可以让您将模型算法的实现与实例化分开并混合使用。

trait Model
trait Result
trait MCMC extends Model {
  def propose: Result
}
trait Importance extends Model {
  def forward: Result
}

class Normal(val model: Model) extends Model

trait NormalMCMCImpl extends MCMC {
  self: Normal =>
  def propose: Result = { //... impl
    val x = self.model // lookie here... I can use vals from Normal
  }
}
trait NormalImportanceImpl extends Importance {
  self: Normal =>
  def forward: Result = { // ... impl
      ...
  }
}

class NormalMCMC(mean: Model) extends Normal(mean)
                              with NormalMCMCImpl

class NormalImportance(mean: Model) extends Normal(mean)
                                    with NormalImportanceImpl

class NormalImportanceMCMC(mean: Model) extends Normal(mean)
                                        with NormalMCMCImpl
                                        with NormalImportanceImpl

- Mitch Blevins

Answer 2

感谢scale-users邮件列表上的Kevin、Mitch、Naftoli Gugenheim和Daniel Sobral，我得到了一个很好的答案。前面两个答案都是可行的，但会导致特征、类和构造函数数量呈指数级增长。然而，使用隐式和视图界限可以避免这个问题。解决方案的步骤如下:

1) 给Normal一个类型参数，表示它的参数类型。 2) 定义隐式函数，将具有正确参数类型的Normal转换为实现适当算法的Normal。例如，makeImportance将Normal[Importance]转换为NormalImportance。 3) 隐式函数需要给定类型边界。原因是，如果不给定类型边界，当您尝试将T的子类型传递给makeImportance时，它将无法工作，因为Normal[T]不是Normal[Importance]的子类型，因为Normal不是协变的。 4) 这些类型边界需要是视图边界，以允许隐式函数链接。

完整解决方案如下:

class Model

trait Importance extends Model {
  def forward: Int
}

trait MCMC extends Model {
  def propose: String
}

class Normal[T <% Model](val arg: T) extends Model

class NormalImportance(arg: Importance) extends Normal(arg) with Importance {
  def forward = arg.forward + 1
}

class NormalMCMC(arg: MCMC) extends Normal(arg) with MCMC {
  def propose = arg.propose + "N"
}

object Normal {
  def apply[T <% Model](a: T) = new Normal[T](a)
}

object Importance {
  implicit def makeImportance[T <% Importance](n: Normal[T]): Importance = 
    new NormalImportance(n.arg)
}

object MCMC {
  implicit def makeMCMC[T <% MCMC](n: Normal[T]): MCMC = new NormalMCMC(n.arg)
}

object Uniform extends Model with Importance with MCMC {
  def forward = 4
  def propose = "Uniform"
}

def main(args: Array[String]) {
  val n = Normal(Normal(Uniform))
  println(n.forward) 
  println(n.propose)
}

- Avi Pfeffer

Answer 3

你的问题很大程度上似乎是因为NormalMCMC和NormalImportance需要参数，但正如你正确地暗示的那样，特质不能有构造函数。

相反，你可以将你想要通过特质构造函数提供的参数作为特质的抽象成员。

当特质被构造时，这些成员就会被实现。

给定：

trait Foo {
  val x : String //abstract
}

你可以将其用作以下任一选项：

new Bar with Foo { val x = "Hello World" }

new Bar { val x = "Hello World" } with Foo

这将为您提供使用Trait构造函数相同的功能。

请注意，如果类型Bar已经具有非抽象的val x : String，那么您可以简单地使用它。

new Bar with Foo

在某些情况下，将x变为惰性也有助于提高灵活性，如果初始化顺序成为问题，则可以更好地解决。

- Kevin Wright