8

我想知道是否可以创建某种“方法调用链”，所有方法都返回相同的 Either[Error,Result]。

我想做的是：依次调用所有方法，当方法返回一个Left（错误）时，停止方法调用并返回调用链中找到的第一个Left。

我尝试了一些东西，包括折叠、地图、投影......但我是 Scala 新手，没有找到任何优雅的解决方案。

我尝试过这样的事情：

def createUserAndMandatoryCategories(user: User) : Either[Error,User] = {
    User.create(user).right.map {
      Logger.info("User created")
      Category.create( Category.buildRootCategory(user) ).right.map {
        Logger.info("Root category created")
        Category.create( Category.buildInboxCategory(user) ).right.map {
          Logger.info("Inbox category created")
          Category.create( Category.buildPeopleCategory(user) ).right.map {
            Logger.info("People category created")
            Category.create( Category.buildTrashCategory(user) ).right.map {
              Logger.info("Trash category created")
              Logger.info("All categories successfully created created")
              Right(user)
            }
          }
        }
      }
    }
  }

但它不起作用。无论如何，我真的不喜欢它需要的缩进。此外，我想将错误转换为描述问题的新字符串（我想我应该使用折叠？）

我正在寻找这样写的东西：

val result : Either[String,CallResult] = call1.something("error 1 description")
.call2.something("error 2 description")
.call3.something("error 3 description")
.call4.something("error 4 description")

有可能用 Scala 做这样的事情吗？也许同时使用 Either 和 Option？

一个限制也是，如果第一次调用失败，则不应进行其他调用。我不想要一个我调用所有东西然后加入其中一个的解决方案。

谢谢！

4

3 回答 3

11

有更好、更实用的方法来做到这一点（主要涉及 Scalaz 的验证和遍历/序列），但您的代码大致相当于：

def createUserAndMandatoryCategories(user: User) : Either[Error,User] = for {
  _ <- User.create(user).right.map(Logger.info("User created")).right
  _ <- Category.create( Category.buildRootCategory(user) ).right.map(Logger.info("Root category created")).right
  _ <- Category.create( Category.buildInboxCategory(user) ).right.map(Logger.info("Inbox category created")).right
} yield user

这至少摆脱了所有的嵌套。由于 ScalaEither默认不偏右，因此您必须手动指定很多次，这会稍微降低可读性。

于 2012-08-24T10:35:17.040 回答
6

您已经在使用的RightProjectionflatMap允许您使用它的方法来做您需要的事情。

（按照惯例，计算结果存储在 中，计算Right失败的错误值存储在 中Left。但没有其他原因，您可以对 . 做同样的事情LeftProjection。）

实际上，我们在这里所拥有的是RightProjection形成一个单子。您可以x使用 将值转换为投影Right(x).right。如果你有一个投影，你可以通过调用来p应用一个可能失败的计算f。这样，您可以链接几个这样的方法。pp.flatMap(f)

这可以通过for理解进一步简化。举一个完整的例子：

object EitherTest extends App {
  // we define some methods that can either fail 
  // and return a String description of the error,
  // or return a value

  def sqrt(x: Double): Either[String,Double] =
    if (x >= 0) Right(math.sqrt(x));
    else Left("Negative value " + x + " cannot be square-rooted.");

  // or you could have, if you want to avoid typing .right inside `for` later
  def sqrt0(x: Double): Either.RightProjection[String,Double] =
    ( if (x >= 0) Right(math.sqrt(x));
      else Left("Negative value " + x + " cannot be square-rooted.")
    ).right;

  def asin(x: Double): Either[String,Double] =
    if (x > 1) Left("Too high for asin")
    else if (x < -1) Left("Too low for asin")
    else Right(math.asin(x));


  // Now we try to chain some computations.
  // In particular, we'll be computing sqrt(asin(x)).
  // If one of them fails, the rest will be skipped
  // and the error of the failing one will be returned
  // as Left.

  { // try some computations
    for(i <- -5 to 5) {
      val input: Double = i / 4.0;
      val d: Either[String,Double] = Right(input);
      val result: Either[String,Double] =
        for(v <- d.right;
            r1 <- asin(v).right;
            r2 <- sqrt(r1).right
            // or you could use:
            // r2 <- sqrt0(r1)
        ) yield r2;
      println(input + "\t->\t" + result);
    }
  }
}

输出是： 

-1.25       ->      Left(Too low for asin)
-1.0        ->      Left(Negative value -1.5707963267948966 cannot be square-rooted.)
-0.75       ->      Left(Negative value -0.848062078981481 cannot be square-rooted.)
-0.5        ->      Left(Negative value -0.5235987755982989 cannot be square-rooted.)
-0.25       ->      Left(Negative value -0.25268025514207865 cannot be square-rooted.)
0.0         ->      Right(0.0)
0.25        ->      Right(0.5026731096270007)
0.5         ->      Right(0.7236012545582677)
0.75        ->      Right(0.9209028607738609)
1.0         ->      Right(1.2533141373155001)
1.25        ->      Left(Too high for asin)
于 2012-08-24T12:20:27.603 回答
2

Debilski 在发挥作用方面有“答案”，但我会用一些帮助代码进一步精简它：

// trait PackageBase (applicable package objects extend)
/*
 * not used in this example but can use below implicit to do something like:
 * for { x <- eitherResult as json }
 */
class RightBiasedEither[A,B](e: Either[A,B]) {
  def as[A1](f: A => A1) = e match {
    case Left(l)    => Left(f(l)).right
    case Right(r) => Right(r).right
  }
}
@inline implicit final def either2Projection[L,R](e: Either[L,R]) = new RightBiasedEither(e)

class Catching[T](f: => T) extends grizzled.slf4j.Logging {
  def either(msg: String) = { // add your own logging here
    try { Right(f).right }
    catch { case e: Exception => error( e.getMessage ); Left(msg).right }
  }
}
def catching[T](f: => T) = new Catching(f)

// in your query wrapper equivalent
protected def either[T](result: => T, msg: String)(implicit ss: Session) = {
  catching(result) either(msg)
}

// and then your DAO create methods will do something like:
def create(foo: Foo)(implicit ss: Session) {
  either[Int]( Foos.insert(foo), i18n("not created") )
}

// with the above code you can then strip things down to:
def createUserAndMandatoryCategories(user: User) : Either[Error,User] = {
  db.handle withSession { implicit ss: Session =>
    ss.withTransaction { 
      val result = for {
        _ <- User.create(user)
        _ <- Category.create( Category.buildRootCategory(user) )
        _ <- Category.create( Category.buildInboxCategory(user) )
      } yield user
      result fold ( e => { ss.rollback; Left(e) }, u => Right(u) )
    }
  }
}

在我看来，没有必要记录成功的创建事件（只有失败），因为整个事务在失败时回滚，但是 YMMV，可以根据需要添加日志记录。

于 2012-08-24T11:11:02.127 回答