在Scala中存储特定类类型的序列？

试图找到一种有效且灵活的方法来在Scala中存储一系列类类型，以便我以后可以使用它们来启动该类型的新实例：

class Event(

  val name: String,
  val channels: Seq[String],
  val processors: Seq[T] // a sequence of processor classes

)

上面序列中的每个处理器都是Akka Actor类。我计划在每次接收数据时创建一个新的参与者，通过如下方式映射处理器：

event.processors.foreach { processorType =>
  val processor = newProcessor(processorType) // does all the Akka creation stuff
  processor ! Data
}

更新：显然上面的说法相当正确，那么我们如何强制执行

Seq[T]

只是处理器类型？因此，坚持使用类，如

类计算器，可以扩展处理器

---

我的猜测是，我遗漏了Scala的一些问题，因此感谢您的帮助。

Seq[T]

只有在存在类型

T

或类型参数时才有效

scala> class Event(val seq:Seq[T])
<console>:7: error: not found: type T
       class Event(val seq:Seq[T])
                               ^

---

Seq[T]

只有在存在类型

T

或类型参数时才有效

scala> class Event(val seq:Seq[T])
<console>:7: error: not found: type T
       class Event(val seq:Seq[T])
                               ^

---

这就是制作道具的目的。使用

Props

的优点是，您可以在运行时将任何想要的参数传递给

处理器

构造函数，而不是被限制为不使用arg构造函数

关于

Props

需要注意的一点是，它采用了一个by-name

creator

参数，因此当您看到

Props（newtestactor）

时，

TestActor

此时实际上并没有创建。它是在您将

道具

传递到

actorOf（）

时创建的

要将

参与者

限制为

处理器

的子类型，可以创建

道具

的子类型

例如：

trait Processor extends Actor

class MyProps(creat: () ⇒ Processor) extends Props(creat)

object MyProps {
  def apply(creator: ⇒ Processor): MyProps = new MyProps(() => creator)
}

您的

事件

类将有一个

Seq[MyProps]

。下面是一个示例测试：

case class Event(      
  name: String,
  channels: Seq[String],
  processors: Seq[MyProps]       
)

class TestActor(bar: String) extends Processor {
  def receive = {
    case msg @ _ => println(bar + " " + msg)
  }
}

object SeqProps extends App {
  override def main(args: Array[String]) {
    val system = ActorSystem()

    val event = new Event("test", Seq("chan1", "chan2", "chan3"), 
      Seq(MyProps(new TestActor("baz")),
          MyProps(new TestActor("barz"))))

    event.processors.foreach { proc =>
      system.actorOf(proc) ! "go!"
    }

    system.shutdown()
  }
}

如果您试图将非

处理器

传递给

MyProps（）

它将在编译时失败

scala> class NotProcessor extends Actor {
     |   def receive = emptyBehavior
     | }
defined class NotProcessor

scala> MyProps(new NotProcessor)
<console>:15: error: type mismatch;
 found   : NotProcessor
 required: Processor
              MyProps(new NotProcessor)
                      ^

scala>类NotProcessor扩展了Actor{
|def接收=清空行为
| }
定义类处理器
scala>MyProps（新处理器）
：15：错误：类型不匹配；
找到：NotProcessor
必需：处理器
MyProps（新处理器）
^
这就是
道具的用途。使用
Props
的优点是，您可以在运行时将任何想要的参数传递给
处理器
构造函数，而不是被限制为不使用arg构造函数

关于
Props
需要注意的一点是，它采用了一个by-name
creator
参数，因此当您看到
Props（newtestactor）
时，
TestActor
此时实际上并没有创建。它是在您将
道具
传递到
actorOf（）
时创建的

要将
参与者
限制为
处理器
的子类型，可以创建
道具
的子类型

例如：

trait Processor extends Actor

class MyProps(creat: () ⇒ Processor) extends Props(creat)

object MyProps {
  def apply(creator: ⇒ Processor): MyProps = new MyProps(() => creator)
}

您的
事件
类将有一个
Seq[MyProps]
。下面是一个示例测试：

case class Event(      
  name: String,
  channels: Seq[String],
  processors: Seq[MyProps]       
)

class TestActor(bar: String) extends Processor {
  def receive = {
    case msg @ _ => println(bar + " " + msg)
  }
}

object SeqProps extends App {
  override def main(args: Array[String]) {
    val system = ActorSystem()

    val event = new Event("test", Seq("chan1", "chan2", "chan3"), 
      Seq(MyProps(new TestActor("baz")),
          MyProps(new TestActor("barz"))))

    event.processors.foreach { proc =>
      system.actorOf(proc) ! "go!"
    }

    system.shutdown()
  }
}

如果您试图将非
处理器
传递给
MyProps（）
它将在编译时失败

scala> class NotProcessor extends Actor {
     |   def receive = emptyBehavior
     | }
defined class NotProcessor

scala> MyProps(new NotProcessor)
<console>:15: error: type mismatch;
 found   : NotProcessor
 required: Processor
              MyProps(new NotProcessor)
                      ^

scala>类NotProcessor扩展了Actor{
|def接收=清空行为
| }
定义类处理器
scala>MyProps（新处理器）
：15：错误：类型不匹配；
找到：NotProcessor
必需：处理器
MyProps（新处理器）
^
发生了什么错误？您是否应该使用某种类型的Seq[Actor]而不是Seq[T]？由于某种原因，Scala IDE今天没有自动编译，所以实际上没有尝试将其固定在sbt中。这真的应该编译吗？如果是的话，这比我想象的要容易。我会做一个更新，但可能有一种方法可以强制执行该类型（仅限于处理器类型）val processors:Seq[T显然这比我想象的要简单得多。去Scala。Noah，我会测试一下，让你知道这是否是一个有效的答案。错误是什么？你应该使用某种Seq[Actor]而不是Seq[T]？由于某种原因，Scala IDE今天没有自动编译，所以实际上没有尝试将其固定在sbt中。这真的应该编译吗？如果是，这比我想象的要容易。另外，我将进行更新，但可能有一种方法可以强制执行该类型（仅限于处理器类型）val processors:Seq[T显然这比我想象的要简单得多。去Scala。Noah，我会测试一下，让你知道这是否是一个有效的答案。
Props
？它在Scala标准库中的什么地方？无论如何，这个答案根本不能回答问题。他说的是akka.actor.Props，它确实是创建akka actors所需要的，因此我认为这个解决方案ion也是正确的。这一种方式还是另一种方式更好取决于newProcessor（…）中的未卸载代码。
def system.actorOf（props:props）：ActorRef
创建一个演员。
道具
？在Scala标准库中它在哪里？无论如何，这个答案根本不能回答这个问题。他说的是akka.actor.Props，它确实是创建akka演员所需要的，因此我认为这个解决方案也是正确的。这个方法还是其他方法更好取决于未显示的代码在newProcessor（…）.
def system.actorOf（props:props）：ActorRef
创建一个参与者。