7

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

示例：假设我有两个算法，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 类型。但显而易见的问题是，如果 mean 同时实现了 MCMC 和 Importance 会怎样？然后我希望 Normal 也实现它们。但我不想创建一个重新实现建议和转发的新类。如果 NormalMCMC 和 NormalImportance 不带参数，我可以使它们成为特征并将它们混合在一起。但在这里我希望混合取决于参数的类型。有没有好的解决方案？

4

3 回答 3

7

使用self 类型允许您将模型算法实现与实例化分离并将它们混合：

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
于 2010-01-10T21:32:33.637 回答
4

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

1) 给 Normal 一个类型参数，表示其参数的类型。2) 定义隐式，将具有正确类型参数的 Normal 用于实现适当算法的参数。例如，makeImportance 接受一个 Normal[Importance] 并产生一个 NormalImportance. 3）隐式需要被赋予类型绑定。原因是在没有类型绑定的情况下，如果您尝试将 Normal[T] 传递给 makeImportance，其中 T 是 Importance 的子类型，它将不起作用，因为 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)
}
于 2010-01-12T18:04:01.250 回答
1

您的大部分问题似乎都是这样NormalMCMC并NormalImportance接受参数，但正如您正确暗示的那样，特征不能有构造函数。

相反，您可以通过 trait 构造函数（如果存在这样的东西）获取您想要提供的参数，并使它们成为 trait 的抽象成员。

然后，当构造特征时，成员就会被实现。

鉴于：

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

于 2010-01-10T17:23:58.887 回答