Scala 高级类型语法

Question

我是 Scala 的新手，也是高级类型的新手。我想写这样的东西；

trait Actor[E[Dependency] <: Event[Dependency]] {
  def execute(dependency: Dependency): Unit
}

但是我不能在execute方法中引用类型参数Dependency - 编译器不知道它。

我知道我可以在没有 HKT 的情况下通过以下方式解决它，但这不是这个问题的目的；

trait Actor[T <: Event[Dependency], Dependency] {
   def execute(dependency: Dependency): Unit
}

我想了解为什么它不适用于我尝试过的更高种类的类型语法？是否有可能用 HKT 表达这一点？这是 HKT 的有效用例吗？

---

编辑

更多信息，Event 看起来像这样；

trait Event[Data] {
   val payload: Data
}

...我正在寻找像这样定义一个事件和一个演员；

case class FooEvent(payload: Foo) extends Event[Foo]

class FooActor extends Actor[FooEvent] {
   def execute(dependency: Foo) = {}
}

Answer 1

我会尝试改进 Alexey 的答案 - 他是对的，但他太矮了。但我必须说我不是 HKT 的专家，我想我才刚刚开始理解这个概念。

在您的代码中，E[Dependency] 与 E[_] 相同，这表示您有 E 以某种类型作为参数。这意味着您不会将Dependency 作为类型进行操作。您也不要对 E 或 E[Dependency] 作为类型进行操作。 E 是一个类型构造函数，如果我理解正确的话，E[Dependency] 是一个存在类型。请注意，

trait Actor[E[D] <: Event[D]] { def execute(d: E) {} }

或

trait Actor[E[D] <: Event[D]] { def execute(d: E[D]) {} }

也不会编译。

您需要指定正确的类型作为执行的参数：

trait Actor[E[D] <: Event[D]] { def execute[B](d: E[B]) {} }

这将编译为E[B] 是此上下文中的类型。

更新：

请看一下这段代码：

  trait Event[P] {
    val payload: P
  }

  case class FooEvent(payload: Int) extends Event[Int]

  trait BaseActor {
    type E = Event[P]
    type P
    def execute(dep: P)
    def runEvent(event: E)
  }

  trait IntActor extends BaseActor {
    type P = Int
  }

  class FooActor extends IntActor {
    def execute(dependency: P) = {}
    def runEvent(event: E) = {}
  }

  val c = new FooActor()
  c.runEvent(FooEvent(5))
  c.execute(5)

基本上，诀窍是定义type P，这是我们的Dependency 和type E = Event[P]，它始终是Event[Dependency]，然后您可以通过定义P 来使用actor，而无需像已经定义的那样定义E。不确定它是否能解决问题，但它看起来像是找我的一种方式。这里的类型也太多了，像IntActor这样的就不需要了。我把它们放在了上面，这样更容易理解这个例子

Answer 2

但是我不能在execute方法中引用类型参数Dependency - 编译器不知道它。

你不能，因为它不是Actor 的参数。考虑

val actor = new Actor[Event] // E is Event
actor.execute(???) // what argument is this supposed to take? I.e. what is Dependency for Actor[Event]?

更新：鉴于您的编辑，[Dependency, T <: Event[Dependency]] 选项正是您需要的。当你写Actor[E[Dependency] <: Event[Dependency]] 时，这意味着E 本身必须有一个类型参数。而FooEvent 不会，所以Actor[FooEvent] 不会编译。

更新 2：您可以尝试如下使用类型成员：

trait Event {
  type Dependency
  val payload: Dependency
}

trait Actor {
  type E <: Event

  def execute(e: E#Dependency)
}

class Foo

case class FooEvent(payload: Foo) extends Event {
  type Dependency = Foo
}

class FooActor extends Actor {
  type E = FooEvent

  def execute(e: Foo) = {}
}