Question

我有一组模型类，以及一组可以在模型上运行的算法。并非所有类型的模型都可以执行所有算法。我希望模型类能够声明它们可以执行的算法。模型可以执行的算法可能取决于其参数。

示例：假设我有两种算法，MCMC和重要性，表示为特征：

trait MCMC extends Model {
  def propose...
}

trait Importance extends Model {
  def forward...
}

我有一个模型类Normal，它采用一个均值参数，它本身就是一个模型。现在，如果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类型。但显而易见的问题是，如果同时实现MCMC和重要性，该怎么办？然后我希望Normal也实现它们。但我不想创建一个重新实现提议和转发的新类。如果NormalMCMC和NormalImportance没有参数，我可以使它们成为特征并将它们混合在一起。但是在这里我希望混合依赖于参数的类型。有一个很好的解决方案吗？

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

Answer 2

感谢Kevin，Mitch和Naftoli Gugenheim以及Daniel Sobral在规模用户邮件列表上，我有一个很好的答案。之前的两个答案有效，但导致特征，类和构造函数的数量呈指数增长。但是，使用implicits和视图边界可以避免此问题。解决方案的步骤是：

1）给Normal一个表示其参数类型的类型参数。 2）定义将具有正确类型参数的Normal带到实现适当算法的那个的implicits。例如，makeImportance采用Normal [Importance]并生成NormalImportance。 3）必须给出一个类型绑定的含义。原因是没有类型绑定，如果你试图将Normal [T]传递给makeImportance，其中T是重要性的子类型，它将无法工作，因为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)
}

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延迟，如果初始化顺序成为问题，这可以为您提供更大的灵活性。

scala：mixins取决于参数的类型

3 个答案: