Scala 转换链如果出错则停止

Question

我想对字符串应用一系列转换，但在出现错误时停止。这是更通用模式的示例(一种责任链模式或访问者模式)

如果可能的话，我现在想避免使用 Cats 或 Scalaz。如果您知道如何在普通 Scala 以及 Cats/Scalaz 上执行此操作，我将很高兴在答案中看到代码;)

因此，以下是我的方法(代码末尾的断言)，但是发现错误时它不会停止。基本上是跳过 X 次转换的执行。

type Error = String

sealed trait Transformer {
  def transform(txt:String) : Either[Error, String]
}

object Transformer1 extends Transformer {
  override def transform(txt: String): Either[Error, String] = Right(s"${txt}_One")
}

object Transformer2 extends Transformer {
  override def transform(txt: String): Either[Error, String] = Right(s"${txt}_Two")
}

object Transformer3 extends Transformer {
  override def transform(txt: String): Either[Error, String] = Right(s"${txt}_Three")
}

object TransformerError extends Transformer {
  override def transform(txt: String): Either[Error, String] = Left("Error!!!!")
}

def transform(txt: String, transformers: Seq[Transformer]): Either[Error, String] =
  transformers.foldLeft(Right(txt):Either[Error, String])( (result, t) =>  result match {
    case Right(txt) => t.transform(txt)
    case error => error
  } )


val tOk = Seq(Transformer1, Transformer2, Transformer3)
val tError = Seq(Transformer1, TransformerError, Transformer3)

assert(transform("Whatever", tOk) == Right("Whatever_One_Two_Three"))
assert(transform("Whatever", tError) == Left("Error!!!!"))

有什么建议吗？

谢谢!!

Answer 1

在 Scala 2.12 中，Either 是右偏的，因此 for-yield 就可以解决问题。

for {
  v1 <- Transformer1.transform("Whatever")
  v2 <- Transformer2.transform(v1)
  v3 <- Transformer3.transform(v2)
} yield {
  v3
}

计算结果为Right(Whatever_One_Two_Three)，而

for {
  v1 <- Transformer1.transform("Whatever")
  v2 <- TransformerError.transform(v1)
  v3 <- Transformer3.transform(v2)
} yield {
  v3
}

计算结果为Left(错误!!!)

但是，如果您想返回应用了所有转换的结果，直到出现错误，即

  assert(transform("Whatever", tError) == Right("Whatever_One"))

那么以下 transform 函数的重构可能会起作用:

  def transform(txt: String, transformers: Seq[Transformer]): Either[Error, String] = {

    type Current = Either[Error, String]
    type Previous = Either[Error, String]

    def foldLeftWithEarlyReturn: Tuple2[Current, Previous] = {
      transformers.foldLeft[Tuple2[Current, Previous]](Right(txt) , Right(txt)){
        (result, t)  => result match {
          case ( Right(txt)  , Right(previousTxt)  )   =>        ( t.transform(txt)  , Right(txt)  )
          case ( Left(error) , Right(previousTxt)  )   => return ( Right(previousTxt), Left(error) )
          case e => e
        }
      }
    }

    if (foldLeftWithEarlyReturn._1.isLeft)
      foldLeftWithEarlyReturn._2 // this means last transformation in sequence resulted in Left, so return previous
    else
      foldLeftWithEarlyReturn._1

  }