如何在Scala中的模块之间传递数据时避免使用asInstanceOf

Question

考虑以下情况：

class Program { }
object Program { }


object Generator{
    val program: Program = new Program

  def met = {
    val mychecker = Checker(program)
    mychecker.check
  }
}

trait Checker {
  val program: Program 
  def check
}

trait Order {
  val checker: Logic
  def met1: Nothing = checker.program
}

object Checker{
  def apply(p: Program) = new { 
    val program: p.type = p
  } with Logic { self =>
    object AnOrder extends {
      val checker: self.type = self     
    } with Order

    val order = AnOrder
  }

}

trait Logic extends Checker { self =>
  protected val order: Order { val checker: self.type }
  def check = order.met1
}

Generator.met

在这里，我写def met1: Nothing 是为了让你明白我的意思，基本上生成器和检查器的程序类型是不同的。所以我得到了

类型不匹配；找到：Order.this.checker.program.type（与 底层类型 Playground.this.Program) 需要：没有

现在，我的问题不是关于这个错误。我想问一下，当您有两个模块 M1 和 M2 时，如何避免使用 asInstanceOf 进行转换，其中一个将 T 类型的一些数据传递给 M2，M2 进行一些计算，然后返回相同的数据类型（直到这个差异，我们见错误）。

在上面的例子中你会怎么做？

现实世界的错误

正如我在我的一个 cmets 中所解释的那样，编译器不会通过更复杂的 Program 实例。例如，请参阅 my project，您无法使用 sbt -> compile 进行编译。您会看到由于这里提到的问题，terminationCache 给出了类型错误，我需要使用 asInstanceOf。

Answer 1

我基本上忽略了您粘贴的代码，但要回答您在文本中提出的问题，您可以执行以下操作：

trait MyTrait {
  def someCommonMethod: Whatever
}

case class Something(foo: Int) extends MyTrait {
  def someCommonMethod: Whatever = ???
}

object M2 {
  def someComputation[T <: MyTrait](t: T): T = {
    //can call t.someCommonMethod in here if you want
    ???
  }
}

object M1 {
  def doSomething(something: Something): Something = {
    M2.someComputation(something)
  }
}

我不能 100% 确定这会回答您的问题，但希望对您有所帮助。

Answer 2

我不明白这个问题。我认为您要么犯了一个单独的错误，并将您的错误归因于您在问题中描述的幻象症状，要么我误解了您。

这是您发布的代码的一个版本，在我看来与您的问题无关的细微调整，编译得很好 (try it here)：

class Program { }
object Program { }
trait Logic {}


object Generator{
    val program: Program = new Program

  def met = {
    val mychecker = Checker(program)
    mychecker.check
  }
}

trait Checker {
  val program: Program 
  def check
}

trait Order {
  val checker: Checker
  def met1: Program = checker.program
}

object Checker{
  def apply(p: Program) = new { 
    val program: p.type = p
  } with Checker { self =>
    object AnOrder extends {
      val checker: self.type = self     
    } with Order

    val order = AnOrder

    def check = println("check here")
  }

}

println("compiled OK")

请注意，我已将def met1: Nothing 更改为def met1: Program，它工作正常。

你问：

当您有两个模块 M1 和 M2 时，如何避免使用 asInstanceOf 进行转换，其中一个将 T 类型的一些数据传递给 M2，M2 进行一些计算，然后返回完全相同的数据类型

我认为当两个模块 M1 和 M2 都与一个公共类型交互时，你不需要使用asInstanceOf，例如在这种情况下为Program。