我最近发布了几个关于 SO 的问题，涉及 Scala特征、表示类型、成员类型、清单和隐式证据。这些问题的背后是我为生物蛋白质网络构建建模软件的项目。尽管得到了非常有用的答案，这些答案让我比我自己能得到的更接近，但我仍然没有为我的项目找到解决方案。有几个答案表明我的设计存在缺陷，这就是解决方案的原因Foo框架式问题在实践中不起作用。在这里，我发布了我的问题的更复杂（但仍然大大简化）的版本。我希望这个问题和解决方案对于试图在 Scala 中构建复杂的特征和类层次结构的人来说将是广泛有用的。
我项目中最高级别的课程是生物反应规则。规则描述了一种或两种反应物如何通过反应转化。每个反应物都是一个图，它具有称为单体的节点和连接单体上命名位点的边。每个站点也有一个它可以处于的状态。编辑：边缘的概念已从示例代码中删除，因为它们使示例复杂化而对问题没有太大贡献。一条规则可能是这样说的：有一种反应物由单体 A 组成，分别通过位点 a1 和 b1 与单体 B 结合；该键被规则破坏，使位点 a1 和 b1 未绑定；同时在单体 A 上，位点 a1 的状态从 U 变为 P。我将其写为：
A(a1~U-1).B(b1-1) -> A(a1~P) + B(b1)
（在 Scala 中解析这样的字符串非常简单，让我头晕目眩。）这-1表明第 1 个键位于这些站点之间——该数字只是一个任意标签。
这是我到目前为止所拥有的内容以及我添加每个组件的原因。它可以编译，但只能无偿使用asInstanceOf. 如何摆脱asInstanceOfs 以使类型匹配？
我用一个基本类来表示规则：
case class Rule(
reactants: Seq[ReactantGraph], // The starting monomers and edges
producedMonomers: Seq[ProducedMonomer] // Only new monomers go here
) {
// Example method that shows different monomers being combined and down-cast
def combineIntoOneGraph: Graph = {
val all_monomers = reactants.flatMap(_.monomers) ++ producedMonomers
GraphClass(all_monomers)
}
}
图的类GraphClass具有类型参数，因为这样我就可以对特定图中允许的单体和边的种类进行限制；例如， a中不能有任何ProducedMonomers 。我还希望能够对特定类型的所有s 说s。我使用类型别名来管理约束。ReactantRulecollectMonomerReactantMonomer
case class GraphClass[
+MonomerType <: Monomer
](
monomers: Seq[MonomerType]
) {
// Methods that demonstrate the need for a manifest on MonomerClass
def justTheProductMonomers: Seq[ProductMonomer] = {
monomers.collect{
case x if isProductMonomer(x) => x.asInstanceOf[ProductMonomer]
}
}
def isProductMonomer(monomer: Monomer): Boolean = (
monomer.manifest <:< manifest[ProductStateSite]
)
}
// The most generic Graph
type Graph = GraphClass[Monomer]
// Anything allowed in a reactant
type ReactantGraph = GraphClass[ReactantMonomer]
// Anything allowed in a product, which I sometimes extract from a Rule
type ProductGraph = GraphClass[ProductMonomer]
单体类MonomerClass也有类型参数，这样我就可以对站点进行约束；例如， aConsumedMonomer不能有 a StaticStateSite。此外，我需要collect特定类型的所有单体，例如，收集产品中规则中的所有单体，因此我在Manifest每个类型参数中添加一个。
case class MonomerClass[
+StateSiteType <: StateSite : Manifest
](
stateSites: Seq[StateSiteType]
) {
type MyType = MonomerClass[StateSiteType]
def manifest = implicitly[Manifest[_ <: StateSiteType]]
// Method that demonstrates the need for implicit evidence
// This is where it gets bad
def replaceSiteWithIntersection[A >: StateSiteType <: ReactantStateSite](
thisSite: A, // This is a member of this.stateSites
monomer: ReactantMonomer
)(
// Only the sites on ReactantMonomers have the Observed property
implicit evidence: MyType <:< ReactantMonomer
): MyType = {
val new_this = evidence(this) // implicit evidence usually needs some help
monomer.stateSites.find(_.name == thisSite.name) match {
case Some(otherSite) =>
val newSites = stateSites map {
case `thisSite` => (
thisSite.asInstanceOf[StateSiteType with ReactantStateSite]
.createIntersection(otherSite).asInstanceOf[StateSiteType]
)
case other => other
}
copy(stateSites = newSites)
case None => this
}
}
}
type Monomer = MonomerClass[StateSite]
type ReactantMonomer = MonomerClass[ReactantStateSite]
type ProductMonomer = MonomerClass[ProductStateSite]
type ConsumedMonomer = MonomerClass[ConsumedStateSite]
type ProducedMonomer = MonomerClass[ProducedStateSite]
type StaticMonomer = MonomerClass[StaticStateSite]
我当前的实现StateSite没有类型参数；它是一个标准的特征层次结构，终止于具有名称和一些Strings 代表适当的状态。（最好使用字符串来保存对象状态；它们实际上是我真实代码中的名称类。）这些特征的一个重要目的是提供所有子类所需的功能。好吧，这不就是所有特质的目的。我的特征很特别，因为许多方法对特征的所有子类共有的对象属性进行了微小的更改，然后返回一个副本。如果返回类型与对象的基础类型匹配，那将是更可取的。这样做的蹩脚方法是将所有特征方法抽象化，并将所需的方法复制到所有子类中。我不确定执行此操作的正确 Scala 方式。一些消息来源建议一种成员类型MyType存储基础类型（此处显示）。其他来源建议使用表示类型参数。
trait StateSite {
type MyType <: StateSite
def name: String
}
trait ReactantStateSite extends StateSite {
type MyType <: ReactantStateSite
def observed: Seq[String]
def stateCopy(observed: Seq[String]): MyType
def createIntersection(otherSite: ReactantStateSite): MyType = {
val newStates = observed.intersect(otherSite.observed)
stateCopy(newStates)
}
}
trait ProductStateSite extends StateSite
trait ConservedStateSite extends ReactantStateSite with ProductStateSite
case class ConsumedStateSite(name: String, consumed: Seq[String])
extends ReactantStateSite {
type MyType = ConsumedStateSite
def observed = consumed
def stateCopy(observed: Seq[String]) = copy(consumed = observed)
}
case class ProducedStateSite(name: String, Produced: String)
extends ProductStateSite
case class ChangedStateSite(
name: String,
consumed: Seq[String],
Produced: String
)
extends ConservedStateSite {
type MyType = ChangedStateSite
def observed = consumed
def stateCopy(observed: Seq[String]) = copy(consumed = observed)
}
case class StaticStateSite(name: String, static: Seq[String])
extends ConservedStateSite {
type MyType = StaticStateSite
def observed = static
def stateCopy(observed: Seq[String]) = copy(static = observed)
}
我最大的问题是像MonomerClass.replaceSiteWithIntersection. 许多方法对类的特定成员进行一些复杂的搜索，然后将这些成员传递给对其进行复杂更改的其他函数并返回一个副本，然后在更高级别对象的副本中替换原来的。我应该如何参数化方法（或类）以便调用是类型安全的？现在我可以让代码编译只有很多asInstanceOf无处不在。Scala 对传递类型或成员参数的实例特别不满意，因为我可以看到两个主要原因：（1）协变类型参数最终作为任何将它们作为输入的方法的输入，以及（2）它是很难让 Scala 相信一个返回副本的方法确实返回了一个与放入的类型完全相同的对象。
毫无疑问，我留下了一些大家都不清楚的东西。如果我需要添加任何细节，或者我需要删除多余的细节，我会尽量快速清理。
编辑
@0__ 用replaceSiteWithIntersection编译时没有asInstanceOf. 不幸的是，我找不到在没有类型错误的情况下调用该方法的方法。他的代码本质上是这个新类中的第一个方法MonomerClass；我添加了调用它的第二种方法。
case class MonomerClass[+StateSiteType <: StateSite/* : Manifest*/](
stateSites: Seq[StateSiteType]) {
type MyType = MonomerClass[StateSiteType]
//def manifest = implicitly[Manifest[_ <: StateSiteType]]
def replaceSiteWithIntersection[A <: ReactantStateSite { type MyType = A }]
(thisSite: A, otherMonomer: ReactantMonomer)
(implicit ev: this.type <:< MonomerClass[A])
: MonomerClass[A] = {
val new_this = ev(this)
otherMonomer.stateSites.find(_.name == thisSite.name) match {
case Some(otherSite) =>
val newSites = new_this.stateSites map {
case `thisSite` => thisSite.createIntersection(otherSite)
case other => other
}
copy(stateSites = newSites)
case None => new_this // This throws an exception in the real program
}
}
// Example method that calls the previous method
def replaceSomeSiteOnThisOtherMonomer(otherMonomer: ReactantMonomer)
(implicit ev: MyType <:< ReactantMonomer): MyType = {
// Find a state that is a current member of this.stateSites
// Obviously, a more sophisticated means of selection is actually used
val thisSite = ev(this).stateSites(0)
// I can't get this to compile even with asInstanceOf
replaceSiteWithIntersection(thisSite, otherMonomer)
}
}