7

如果它通过条件列表，我正在开发一种应该持久化对象的方法。

如果任何（或许多）条件失败（或出现任何其他类型的错误），则应返回包含错误的列表，如果一切顺利，则应返回已保存的实体。

我在想这样的事情（当然是伪代码）：

request.body.asJson.map { json =>
  json.asOpt[Wine].map { wine =>
    wine.save.map { wine => 
      Ok(toJson(wine.update).toString)
    }.getOrElse  { errors => BadRequest(toJson(errors))}
  }.getOrElse    { BadRequest(toJson(Error("Invalid Wine entity")))}
}.getOrElse      { BadRequest(toJson(Error("Expecting JSON data")))}

也就是说，我想把它当作一个 Option[T]，如果任何验证失败，而不是返回None它会给我错误列表......

这个想法是返回一系列 JSON 错误......

所以问题是，这是处理这种情况的正确方法吗？在 Scala 中实现它的方法是什么？

--

糟糕，刚刚发布了问题并发现了

http://www.scala-lang.org/api/current/scala/Either.html

无论如何，我想知道您对所选方法的看法，以及是否有其他更好的选择来处理它。

4

4 回答 4

13

使用 scalaz 你有Validation[E, A]，它类似于Either[E, A]但具有 ifE是一个半组（意思是可以连接的东西，如列表）的属性，而不是多个验证结果可以以保留所有发生的错误的方式组合。

例如，使用 Scala 2.10-M6 和 Scalaz 7.0.0-M2，其中 Scalaz 有一个自定义Either[L, R]命名\/[L, R]，默认情况下是右偏的：

import scalaz._, Scalaz._

implicit class EitherPimp[E, A](val e: E \/ A) extends AnyVal {
  def vnel: ValidationNEL[E, A] = e.validation.toValidationNEL
}

def parseInt(userInput: String): Throwable \/ Int = ???
def fetchTemperature: Throwable \/ Int = ???
def fetchTweets(count: Int): Throwable \/ List[String] = ???

val res = (fetchTemperature.vnel |@| fetchTweets(5).vnel) { case (temp, tweets) =>
  s"In $temp degrees people tweet ${tweets.size}"
}

这result是一个Validation[NonEmptyList[Throwable], String]，包含所有发生的错误（温度传感器错误和/或 twitter 错误或 none）或成功消息。然后，您可以切换回\/方便。

注意：Either 和 Validation 的区别主要在于 Validation 可以累积错误，但不能flatMap丢失累积的错误，而使用 Either 不能（轻松）累积但可以flatMap（或在理解中）并且可能丢失除了第一条错误信息。

关于错误层次结构

我想这可能会让你感兴趣。不管使用 scalaz/ Either/ \// Validation，我都觉得上手很容易，但接下来需要做一些额外的工作。问题是，如何以有意义的方式从多个错误函数中收集错误？当然，您可以在任何地方使用ThrowableorList[String]并享受轻松的时光，但听起来不太实用或可解释。想象一下得到一个错误列表，如“缺少儿童年龄”::“IO 错误读取文件”::“除以零”。

所以我的选择是创建错误层次结构（使用 ADT-s），就像将 Java 的已检查异常包装到层次结构中一样。例如：

object errors {

  object gamestart {
    sealed trait Error
    case class ResourceError(e: errors.resource.Error) extends Error
    case class WordSourceError(e: errors.wordsource.Error) extends Error
  }

  object resource {
    case class Error(e: GdxRuntimeException)
  }

  object wordsource {
    case class Error(e: /*Ugly*/ Any)
  }

}

然后，当使用具有不同错误类型的错误函数的结果时，我将它们加入到相关的父错误类型下。

for {
  wordSource <-
    errors.gamestart.WordSourceError <-:
    errors.wordsource.Error <-:
    wordSourceCreator.doCreateWordSource(mtRandom).catchLeft.unsafePerformIO.toEither

  resources <-
    errors.gamestart.ResourceError <-:
    GameViewResources(layout)

} yield ...

这里f <-: e映射f左边的函数，e: \/因为\/是一个双函子。因为se: scala.Either你可能有se.left.map(f)。

这可以通过提供shapeless HListIso s 以绘制漂亮的错误树来进一步改进。

修订

更新：(e: \/).vnel将故障侧提升为 a NonEmptyList，因此如果我们有故障，我们至少有一个错误（是：或没有）。

于 2012-08-22T09:04:48.597 回答
4

如果您有Option值，并且希望将它们转换为成功/失败值，则可以使用or方法将 anOption转换为 an 。EithertoLefttoRight

通常 aRight代表成功，所以使用o.toRight("error message")turn Some(value)intoRight(value)和Noneinto Left("error message")。

不幸的是，Scala 默认情况下无法识别这种右偏，因此您必须跳过一个圈（通过调用该.right方法）才能整齐地组合您Either的 s 以供理解。

def requestBodyAsJson: Option[String] = Some("""{"foo":"bar"}""")

def jsonToWine(json: String): Option[Wine] = sys.error("TODO")

val wineOrError: Either[String, Wine] = for {
  body <- requestBodyAsJson.toRight("Expecting JSON Data").right
  wine <- jsonToWine(body).toRight("Invalid Wine entity").right
} yield wine
于 2012-08-22T09:15:07.183 回答
2

Either[A,Option[B]]如果你需要一个空值，你可以使用 lift代替使用Box，它可以有三个值：

  • Full（有一个有效的结果）
  • Empty（没有结果，但也没有错误）
  • Failure（发生错误）

Box比Either丰富的 API更灵活。当然，尽管它们是为 Lift 创建的，但您可以在任何其他框架中使用它们。

于 2012-08-22T08:02:32.533 回答
0

好吧，这是我尝试使用 Either

def save() = CORSAction { request =>
  request.body.asJson.map { json =>
    json.asOpt[Wine].map { wine =>
      wine.save.fold(
        errors => JsonBadRequest(errors),
        wine => Ok(toJson(wine).toString)
      )
    }.getOrElse     (JsonBadRequest("Invalid Wine entity"))
  }.getOrElse       (JsonBadRequest("Expecting JSON data"))
}

而 wine.save 如下所示：

def save(wine: Wine): Either[List[Error],Wine] = {

  val errors = validate(wine)
  if (errors.length > 0) {
    Left(errors)
  } else {
    DB.withConnection { implicit connection =>
      val newId = SQL("""
        insert into wine (
          name, year, grapes, country, region, description, picture
        ) values (
          {name}, {year}, {grapes}, {country}, {region}, {description}, {picture}
        )"""
      ).on(
        'name -> wine.name, 'year -> wine.year, 'grapes -> wine.grapes,
        'country -> wine.country, 'region -> wine.region, 'description -> wine.description,
        'picture -> wine.picture
      ).executeInsert()

      val newWine = for {
        id <- newId;
        wine <- findById(id)
      } yield wine

      newWine.map { wine =>
        Right(wine)
      }.getOrElse {
        Left(List(ValidationError("Could not create wine")))
      }
    }
  }
}

Validate 检查几个先决条件。我仍然需要添加一个 try/catch 来捕获任何 db 错误

我仍在寻找一种方法来改善整个事情，感觉很冗长，符合我的口味......

于 2012-08-23T06:45:47.933 回答