不同类型任务的功能组合 - Scala

Question

目前，我正在设计一个在 Scala 中构建通用管道的设计（纯粹用于学习目的）。为此，我从一个基本结构 Task 开始，它需要一些 TaskConfiguration（现在，我们可以假设这个 TaskConfiguration 是一个特定于 Task 功能的案例类）。特征结构如下：

trait Task[T <: TaskConfiguration] {
  type Out

  def taskConfiguration: T
  def execute(previousOutput: Option[Out]): Option[Out]
}

要求： 1. 我可以有多个扩展任务特征的任务。比如，ReadTask、WriteTask 等， 2. 每个任务都有自己的“out”类型

我的问题是：给定一个 List[Task]，我如何编写方法调用来执行。尝试了多种方法来组合它们，但我一直遇到问题，即我无法区分以前的任务和当前任务的输出，因为我只有一个类型成员来指定此任务可以处理的内容。

我希望我们可以用 Scala 解决这个问题。但考虑到我对使用 Scala 进行函数式编程还很陌生，我想不通。非常感谢您。

注意：对这个问题的描述可能有点脱离上下文。但这是我能想到的最好的，在这个时候。如果您认为我们可以做得更好，请随意编辑。如果您觉得这个问题没有任何意义，请在 cmets 中提出您的想法，以便我处理。

Answer 1

您可以使用类似于 Scala 函数中的andThen 的模式。

我编译了一个小例子：

import scala.util.{Try, Success, Failure}

type TaskConfiguration = Any

trait Task[-C <: TaskConfiguration, +O <: TaskConfiguration] {

  def execute(configuration: C): Option[O]

  def andThen[O2 <: TaskConfiguration](secondTask: Task[O, O2]): Task[C, O2] = {
    val firstTask = this

    new Task[C, O2] {
       def execute(configuration: C): Option[O2] =
         firstTask.execute(configuration).flatMap(secondTask.execute(_))
    }
  }
}

// From here on it's the example!

case class UnparsedNumber(value: String)

trait ParsedNumber {
  val value: Int
}

case class ParsedPositiveNumber(int: Int) extends ParsedNumber {
  val value: Int = int
}

case class HumanReadableNumber(value: String)


val task1 = new Task[UnparsedNumber, ParsedPositiveNumber] {
  def execute(configuration: UnparsedNumber): Option[ParsedPositiveNumber] = {
    Try(configuration.value.toInt) match {
      case Success(i) if i >= 0 => Some(ParsedPositiveNumber(i))
      case Success(_) => None
      case Failure(_) => None
    }
  }
}

val task2 = new Task[ParsedNumber, HumanReadableNumber] {
  def execute(configuration: ParsedNumber): Option[HumanReadableNumber] = {
    if(configuration.value < 1000 && configuration.value > -1000)
      Some(HumanReadableNumber(s"The number is $configuration"))
    else
      None
  }
}

val combined = task1.andThen(task2)

println(combined.execute(UnparsedNumber("12")))
println(combined.execute(UnparsedNumber("12x")))
println(combined.execute(UnparsedNumber("-12")))
println(combined.execute(UnparsedNumber("10000")))
println(combined.execute(UnparsedNumber("-10000")))

Try it out!

---

编辑：

关于您的 cmets，这种方法可能更符合您的要求：

case class Task[-C, +O](f: C => Option[O]) {

  def execute(c: C): Option[O] = f.apply(c)
}

case class TaskChain[C, O <: C](tasks: List[Task[C, O]]) {

  def run(initial: C): Option[O] = {

    def runTasks(output: Option[C], tail: List[Task[C, O]]): Option[O] = {
      output match {
        case Some(o) => tail match {
          case head :: Nil => head.execute(o)
          case head :: tail => runTasks(head.execute(o), tail)
          case Nil => ??? // This should never happen!
        }
        case None => None
      }
    }

    runTasks(Some(initial), tasks)
  }
}

// Example below:

val t1: Task[Int, Int] = Task(i => Some(i * 2))
val t2: Task[Int, Int] = Task(i => Some(i - 100))
val t3: Task[Int, Int] = Task(i => if(i > 0) Some(i) else None)


val chain: TaskChain[Int, Int] = TaskChain(List(t1, t2, t3))

println(chain.run(100))
println(chain.run(10))

Try it out!

引用：

您需要了解的是，如果您将Tasks 打包在List[Task] 中并将其用作Tasks 的链，则输出必须至少是输入的子类型。 C <: TaskConfiguration 和 O <: C 导致：O <: C <: TaskConfiguration 这也意味着 O <: TaskConfiguration。

---

如果您不理解其中的任何部分，我很乐意进一步解释。

我希望这会有所帮助。

Answer 2

我建议看看cats and free monads 可以为您提供什么。按照这种方法，我将开始定义用于定义管道程序的 ADT。类似的东西：

trait TaskE[Effect]
case class ReadTask[Input, SourceConfig](source: SourceConfig) extends TaskE[Input]
case class WriteTask[Output, SinkConfig](out: Output, sink: SinkConfig) extends TaskE[Unit]

然后应用 Free monads（如上面链接中所述）来定义您的管道流。比如：

val pipeline: Task[Unit] = 
  for {
    input1 <- read(source1)
    input2 <- read(source2)
    _      <- write(input1 + input2, sink1)
  } yield ()

现在它将取决于编译器（这是一个自然的转换，描述了如何从Task[A] 转换为F[A]，而F 可能是Id，Try，Future，... ) 你定义这个程序将如何运行：

val myCompiler: Task ~> Id = ???
val tryCompiler: Task ~> Try = ???

pipeline.foldMap(myCompiler)  // Id[Unit]
pipeline.foldMap(tryCompiler) // Try[Unit]

您可以拥有任意数量的“编译器”，这并不意味着更改您的管道（“程序”）定义。