10

我最近发布了几个关于 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)
  }
}
4

4 回答 4

6

我已将您的问题简化为特征，并且我开始理解为什么您会遇到强制转换和抽象类型的麻烦。

您实际上缺少的是临时多态性，您可以通过以下方式获得它： - 编写一个具有泛型签名的方法，依赖于相同泛型的隐式来委派工作 - 使隐式仅可用于该泛型的特定值参数，当您尝试执行非法操作时，它将变成“隐式未找到”编译时错误。

现在让我们按顺序来看问题。首先是您的方法的签名是错误的，原因有两个：

  • 替换站点时，您希望创建新泛型类型的新单体，就像您向集合中添加作为现有泛型类型的超类的对象时所做的一样：您将获得一个类型参数为超类的新集合. 结果，您应该产生这个新的单体。

  • 您不确定该操作是否会产生结果（以防您无法真正替换状态）。在这种情况下，正确的类型是 Option[T]

    def replaceSiteWithIntersection[A >: StateSiteType <: ReactantStateSite]
(thisSite: A, monomer: ReactantMonomer): Option[MonomerClass[A]]

如果我们现在在类型错误中查看挖掘机，我们可以看到真正的类型错误来自此方法：

 thisSite.createIntersection

原因很简单：它的签名与您的其他类型不一致，因为它接受 ReactantSite 但您想将其作为参数之一传递给您的 stateSite （类型为 Seq[StateSiteType] ）但您无法保证那

StateSiteType<:<ReactantSite

现在让我们看看证据如何帮助您：

trait Intersector[T] {
  def apply(observed: Seq[String]): T
}


trait StateSite {

  def name: String
}

trait ReactantStateSite extends StateSite {

  def observed: Seq[String]

  def createIntersection[A](otherSite: ReactantStateSite)(implicit intersector: Intersector[A]): A = {
    val newStates = observed.intersect(otherSite.observed)
    intersector(newStates)
  }
}


import Monomers._
trait MonomerClass[+StateSiteType <: StateSite] {

    val stateSites: Seq[StateSiteType]



    def replaceSiteWithIntersection[A >: StateSiteType <: ReactantStateSite](thisSite: A, otherMonomer: ReactantMonomer)(implicit intersector:Intersector[A], ev: StateSiteType <:< ReactantStateSite): Option[MonomerClass[A]] = {

      def replaceOrKeep(condition: (StateSiteType) => Boolean)(f: (StateSiteType) => A)(implicit ev: StateSiteType<:<A): Seq[A] = {
        stateSites.map {
                         site => if (condition(site)) f(site) else site
                       }
      }


      val reactantSiteToIntersect:Option[ReactantStateSite] = otherMonomer.stateSites.find(_.name == thisSite.name)
      reactantSiteToIntersect.map {
               siteToReplace =>
               val newSites = replaceOrKeep {_ == thisSite } { item => thisSite.createIntersection( ev(item) ) }
               MonomerClass(newSites)
             }


    }


  }

object MonomerClass {
  def apply[A <: StateSite](sites:Seq[A]):MonomerClass[A] =  new MonomerClass[A] {
    val stateSites = sites
  }
}
object Monomers{

  type Monomer = MonomerClass[StateSite]
  type ReactantMonomer = MonomerClass[ReactantStateSite]
  type ProductMonomer = MonomerClass[ProductStateSite]
  type ProducedMonomer = MonomerClass[ProducedStateSite]

}

  1. 请注意，如果您以巧妙的方式使用隐式解析规则（例如，您将昆虫放在 Intersector 特征的伴生对象中，这样它将自动解析），则可以在没有特殊导入的情况下使用此模式。

  2. 虽然此模式完美运行，但存在与您的解决方案仅适用于特定 StateSiteType 的事实相关的限制。Scala 集合解决了一个类似的问题，添加了另一个隐式调用 CanBuildFrom。在我们的例子中，我们称之为 CanReact

您将不得不使您的 MonomerClass 保持不变，但这可能是一个问题（但是，为什么需要协方差？）

trait CanReact[A, B] {
  implicit val intersector: Intersector[B]

  def react(a: A, b: B): B

  def reactFunction(b:B) : A=>B = react(_:A,b)
}

object CanReact {

  implicit def CanReactWithReactantSite[A<:ReactantStateSite](implicit inters: Intersector[A]): CanReact[ReactantStateSite,A] = {
    new CanReact[ReactantStateSite,A] {
      val intersector = inters

      def react(a: ReactantStateSite, b: A) = a.createIntersection(b)
    }
  }
}

trait MonomerClass[StateSiteType <: StateSite] {

    val stateSites: Seq[StateSiteType]



    def replaceSiteWithIntersection[A >: StateSiteType <: ReactantStateSite](thisSite: A, otherMonomer: ReactantMonomer)(implicit canReact:CanReact[StateSiteType,A]): Option[MonomerClass[A]] = {

      def replaceOrKeep(condition: (StateSiteType) => Boolean)(f: (StateSiteType) => A)(implicit ev: StateSiteType<:<A): Seq[A] = {
        stateSites.map {
                         site => if (condition(site)) f(site) else site
                       }
      }


      val reactantSiteToIntersect:Option[ReactantStateSite] = otherMonomer.stateSites.find(_.name == thisSite.name)
      reactantSiteToIntersect.map {
               siteToReplace =>
               val newSites = replaceOrKeep {_ == thisSite } { canReact.reactFunction(thisSite)}
               MonomerClass(newSites)
             }


    }


  }

有了这样的实现，当你想用不同类型的另一个站点替换一个站点时，你所需要的就是使用不同类型的 CanReact 的新隐式实例。

最后，我将（我希望）清楚地解释为什么你不需要协方差。

假设您有 aConsumer[T]和 a Producer[T]。

当您想提供给Consumer[T1]a Producer[T2]where时，您需要协方差T2<:<T1。但是如果需要在T1内部使用T2产生的值，可以

class ConsumerOfStuff[T <: CanBeContained] {

  def doWith(stuff: Stuff[T]) = stuff.t.writeSomething

}

trait CanBeContained {
  def writeSomething: Unit
}

class A extends CanBeContained {
  def writeSomething = println("hello")
}


class B extends A {
  override def writeSomething = println("goodbye")
}

class Stuff[T <: CanBeContained](val t: T)

object VarianceTest {

  val stuff1 = new Stuff(new A)
  val stuff2 = new Stuff(new B)
  val consumerOfStuff = new ConsumerOfStuff[A]
  consumerOfStuff.doWith(stuff2)

}

这东西显然不能编译：

错误：类型不匹配；found : Stuff[B] required: Stuff[A] 注意：B <: A，但 Stuff 类在类型 T 中是不变的。您可能希望将 T 定义为 +T。(SLS 4.5) consumerOfStuff.doWith(stuff2)。

但同样，这来自对方差使用的误解，如在设计业务应用程序时如何使用协方差和反方差？Kris Nuttycombe 回答解释。如果我们像下面这样重构

class ConsumerOfStuff[T <: CanBeContained] {

  def doWith[A<:T](stuff: Stuff[A]) = stuff.t.writeSomething

}

你可以看到一切编译正常。

于 2012-07-25T14:01:36.187 回答
2

不是答案，但我可以通过查看问题观察到：

  • 我看到MonomerClass但没有Monomer

我的胆量说你应该尽可能避免清单，因为你已经看到它们会使事情变得复杂。我不认为你会需要它们。例如中的justTheProductMonomers方法GraphClass——既然你可以完全控制你的类层次结构，为什么不直接添加任何涉及运行时检查的测试方法Monomer呢？例如

trait Monomer {
   def productOption: Option[ProductMonomer]
}

那么你会有

def justTheProductMonomers : Seq[ProductMonomer] = monomers.flatMap( _.productOption )

等等。

这里的问题是，您似乎可以拥有一个满足产品谓词的通用单体，而您却以某种方式想要 sub-type ProductMonomer。

我给出的一般建议是首先定义处理规则所需的测试矩阵，然后将这些测试作为方法放入特定特征中，除非您有一个可以进行模式匹配的平面层次结构，即更容易，因为消歧将集中在您的使用站点上，而不是分布在所有实现类型中。

也不要试图用编译时类型约束来逾期。通常在运行时检查一些约束是非常好的。这样至少你可以构建一个完全工作的系统，然后你可以尝试找出可以将运行时检查转换为编译时检查的点，并决定是否值得付出努力。在 Scala 中解决类型级别的问题很有吸引力，因为它很复杂，但它也需要最多的技能才能正确完成。

于 2012-07-24T17:51:32.983 回答
1

有多个问题。首先，整个方法很奇怪：一方面你传入了一个monomer参数，如果thisState找到了参数，该方法与接收者无关——那为什么这根本是一个方法而 MonomerClass不是“自由浮动” " 函数——另一方面，this如果thisSite未找到，则返回返回。既然你原来也有implicit evidence: MyType <:< ReactantMonomer，我猜整个monomer论点已经过时了，你实际上想对new_this.

稍微清理一下，暂时忘记清单，你可以

case class MonomerClass[+StateSiteType <: StateSite, +EdgeSiteType <: EdgeSite](
  stateSites: Seq[StateSiteType], edgeSites: Seq[EdgeSiteType]) {

  def replaceSiteWithIntersection[A <: ReactantStateSite { type MyType = A }]
  (thisSite: A)(implicit ev: this.type <:< MonomerClass[A, ReactantEdgeSite])
  : MonomerClass[A, ReactantEdgeSite] = {
    val monomer = ev(this)
    monomer.stateSites.find(_.name == thisSite.name) match {
      case Some(otherSite) => 
        val newSites = monomer.stateSites map {
          case `thisSite` => thisSite.createIntersection(otherSite)
          case other      => other
        }
        monomer.copy(stateSites = newSites)
      case None => monomer
    }
  }
}

这是一个有趣的问题，我花了一些迭代来摆脱（错误的！）演员表。现在它实际上是非常可读的：此方法仅限于StateSiteType实际上A是ReactantStateSite. 因此，类型参数A <: ReactantStateSite { type MyType = A }——最后一点很有趣，这对我来说是一个新发现：您可以在此处指定类型成员以确保您的返回类型 fromcreateIntersection实际上是A.

您的方法仍然有些奇怪，因为如果我没记错的话，您最终会调用x.createIntersection(x)（thisSite与自身相交，这是一个无操作）。

于 2012-07-24T23:11:51.490 回答
0

有一个缺陷replaceSiteWithIntersection是，根据方法签名，thisSite( A) 的类型是 的超类型和StateSiteType的子类型ReactantStateSite。

但是你最终将它转换为StateSiteType with ReactantStateSite. 这对我来说没有意义。

你从哪里得到的保证A突然是一个StateSiteType？

于 2012-07-24T19:22:39.913 回答