2 
trait A extends Actor {
  private val s = Set[Int]()

  override def act() {
    loop {
      react {
        // case code that modifies s
      }
    }
  }
}

trait B extends Actor {
  private val t = Set[String]()

  override def act() {
    loop {
      react {
        // case code that modifies t
      }
    }
  }
}

val c = new C with A with B //...?

我真正想要的是某种自动组合B.act() and C.act()，但使用 trait mix-ins，只会B.act()被调用。有没有简单的方法来实现这一点？

编辑：这是我找到的半解决方案。我说“一半”是因为原始特征不再扩展Actor，并且C with A with B需要定义为一个类而不是动态混合。也许我应该称之为“四分之一解决方案”？

4

2 回答 2

1

也许您可以创建一个将消息转发到其他 Actor 列表的特征，这样您就不必修改Aor B：

trait C extends Actor {
  private val acts: Seq[Actor] = Seq(new A{}, new B{})

  override def act() {
    acts foreach (_.start)
    loop {
      react { case x => acts foreach { _ ! x } }
    }
  }
}

当您实例化它时，您当然可以保留acts抽象或用不同的集合覆盖它。

于 2012-04-23T00:52:32.330 回答
1

扩展 Actor 类：

import actors.Actor

class MixableActor extends Actor {
  protected var acts = List[PartialFunction[Any, Unit]]()

  final override def act() {
    loop {
      react {
        acts.reduce((a, b) => a orElse b)
      }
    }
  }

  final def receive(act: PartialFunction[Any, Unit]) {
    acts = act :: acts
  }
}

示例代码：

abstract class Node extends MixableActor {
  ...
}

trait User extends MixableActor {
  val files = scala.collection.mutable.Set[Data]()
}

trait Provider extends User {
  receive({
    case ("provide", file: Data) =>
      provide(file)
  }: PartialFunction[Any, Unit])
}

trait Consumer extends User {
  receive({
    case ("consume", file: Data) =>
      consume(file)
  }: PartialFunction[Any, Unit])
}

样品用法：

val provider = new Node with Provider
val consumer = new Node with Consumer
val provider_and_consumer = new Node with Provider with Consumer
于 2012-05-30T22:59:08.420 回答