Question

我们假设我有两个计算结果列表

val a: List[ Throwable \/ A] = ...
val b: List[ Throwable \/ B] = ...

我有计算最终结果的功能，如

def calc(a: A, b: B): Throwable \/ C = ...

我需要为每个a和b计算所有结果，如果有的话还要积累Throwable。是否有任何优雅的方式，如Applicative样式<*>？

UPDT：结果必须是以下

val c: List[ Throwable \/ C] ..

我遇到的最好的解决方案是

def combine[A, B, C](f: (A, B) => Throwable \/ C, a: Throwable \/ A, b: Throwable \/ B): List[Throwable] \/ C = (a, b) match{
    case ( -\/(errA), \/-(_)) => -\/(List(errA))
    case (\/-(_), -\/(errB)) => -\/(List(errB))
    case (-\/(errA), -\/(errB)) => -\/(List(errA, errB))
    case (\/-(valA), \/-(valB)) => f(valA, valB).leftMap( List(_))
  }

而不是

val result = (a |@| b)(combine(calc, _, _))

但在那种情况下，我有一些额外的结果。结果列表的类型为List[ List[Throwable] \/ C]

Answer 1

我不确定我是否完全理解这个问题，但是我会对它进行一次尝试，并希望能够足够接近你的推断。假设您已获得Throwable \/ A类型值和Throwable \/ B中另一个值的列表，并且您希望将它们与函数(A, B) => Throwable \/ C成对组合成累积错误列表或C的列表。我会这样写：

import scalaz._, Scalaz._

def process[A, B, C](
  as: List[Throwable \/ A],
  bs: List[Throwable \/ B]
)(f: (A, B) => Throwable \/ C): NonEmptyList[Throwable] \/ List[C] = ???

我们有很多方法可以实现这一点，但基本的想法是我们需要暂时将析取转换为验证，以便获得我们想要的错误累积（请参阅我的问题here讨论为什么这是必要的。）

def process[A, B, C](
  as: List[Throwable \/ A],
  bs: List[Throwable \/ B]
)(f: (A, B) => Throwable \/ C): NonEmptyList[Throwable] \/ List[C] =
  as.zip(bs).traverseU {
    case (a, b) =>
      val validatedA: ValidationNel[Throwable, A] = a.validation.toValidationNel
      val validatedB: ValidationNel[Throwable, B] = b.validation.toValidationNel

      validatedA.tuple(validatedB).disjunction.flatMap {
        case (a, b) => f(a, b).leftMap(NonEmptyList(_))
      }.validation
  }.disjunction

这里我们将每对值转换为验证，使用applicative tuple将它们组合起来，同时累积错误，转换回析取，以便我们可以与f绑定，返回验证我们可以使用traverseU进行适当的排序，然后再回到分离。

（请注意，我假设这些列表具有相同的长度，或者您不介意忽略其中任何一个的额外结果，但这只是为了简单起见 - 它＆＃如果你想要其他行为，可以很容易地调整。）

Answer 2

最后，我找到了一个合适的解决方案。我们的想法是使用monad变换器EitherT。

val a: List[Throwable \/ A] = ...
val b: List[Throwable \/ B] = ...
val aT = EitherT.eitherT(a)
// aT: scalaz.EitherT[List,Throwable, A] = ...
val bT = EitherT.either(b)
// bT: scalaz.EitherT[List,Throwable, B] = ...

接下来是魔术：

val result = (aT |@| bT)(calc( _, _ ))
// c: scalaz.EitherT[[+A]List[A],Throwable,C] = ...

我们从＆＃39; a＆＃39;中获取所有＆＃34;好的＆＃34; *值和所有＆＃34;好＆＃34;来自＆＃39;＆＃39;的值像通常的Applicative样式函数调用。并且没有额外的功能或结果中的额外数据。

＆＃39; *＆＃39; - 期限＆＃34;好＆＃34;意味着不是“可扔”＆＃39;

如何在scalaz` \ / notation

2 个答案: