UPDATE！

Question

我正在玩Scala。我有这样的事情：

trait Test {
  type SweetType

  def methodA(l: String, esc: Boolean): SweetType
  def methodB(a: SweetType): String
}

class MyTest extends Test {

  override type SweetType = (String, Boolean)

  override def methodA(l: String, esc: Boolean): (String, Boolean) = ???

  override def methodB(a: (String, Boolean)): String = ???
}

object Test {
  def apply(): Test = new MyTest()
}

MyTest是Test的具体实现，我想保持 trait 级别而没有定义 SweetType ，只是设计信息。

trait SomethingElse {    
  val test:Test
  def methodA(a:test.SweetType):String
}

此特征的具体实现将使用Test提供的内容。

class MySomethingElse extends SomethingElse {
  val test = Test()

  override def methodA(a:test.SweetType):String = test.methodB(a) + "Cuanak"

}

这是我的问题，这是scala-legal，但做得对吗？或者我应该使用不透明的特性或类似的东西？我只想参考Test＆＃34; SweetType＆＃34;

中定义的抽象类型的任何具体实现。

编辑我忘记了特质测试中的参考

UPDATE！

对于我的案例，最好使用＆＃34;蛋糕模式＆＃34;

trait TestComponent {

  val test:Test

  trait Test {
    type SweetType

    def methodA(l: String, esc: Boolean): SweetType

    def methodB(a: SweetType): String
  }

  class MyTest extends Test {

    override type SweetType = (String, Boolean)

    override def methodA(l: String, esc: Boolean): (String, Boolean) = ???

    override def methodB(a: (String, Boolean)): String = ???
  }

}


trait SomethingElseComponent {
  this :TestComponent =>

  trait SomethingElse {

    def methodA(a:Test#SweetType):String
  }


  class MySomethingElse extends SomethingElse {

    override def methodA(a:Test#SweetType):String = test.methodB(a) + "Cuanak"

  }
}

Answer 1

您的代码看起来很适合我。这是一种常见模式：具有抽象和具体成员的trait，一个为抽象成员提供细节的对象。而且，正如您所观察到的，您可以将trait抽象val放在另一个trait中以聚合所有抽象成员。

这在数学上类似于制作与其他抽象结构相关的抽象结构：

trait Ring {
  type E
  def add(x: E, y: E): E
  def mul(x: E, y: E): E
  def minus(x: E): E
  val zero: E
  val one: E
}

trait Module {
  val ring: Ring
  import ring._

  type V

  def add(x: V, y: V): V
  def mul(x: E, y: V): V
}

另一个Scala抽象类型和路径依赖情况

UPDATE！

1 个答案: