1

我遇到了下面的通用函数，它接受两种Either类型和一个函数作为参数。如果两个参数都Either.Right对它应用函数并返回结果，如果任何一个参数是Either.Left它返回 NonEmptyList(Either.Left)。基本上它执行独立操作并累积错误。

fun <T, E, A, B> constructFromParts(a: Either<E, A>, b: Either<E, B>, fn: (Tuple2<A, B>) -> T): Either<Nel<E>, T> {
    val va = Validated.fromEither(a).toValidatedNel()
    val vb = Validated.fromEither(b).toValidatedNel()
    return Validated.applicative<Nel<E>>(NonEmptyList.semigroup()).map(va, vb, fn).fix().toEither()
}

val error1:Either<String, Int> = "error 1".left()
val error2:Either<String, Int> = "error 2".left()

val valid:Either<Nel<String>, Int> = constructFromParts(
        error1,
        error2
){(a, b) -> a+b}

fun main() {
    when(valid){
        is Either.Right -> println(valid.b)
        is Either.Left -> println(valid.a.all)
    }
}

上面的代码打印

[error 1, error 2]

在函数内部，它将 Either 转换为 ValidatedNel 类型并累积两个错误 （ Invalid(e=NonEmptyList(all=[error 1])) Invalid(e=NonEmptyList(all=[error 2])) ）

我的问题是它如何执行此操作，或者任何人都可以从代码中解释以下行。

return Validated.applicative<Nel<E>>(NonEmptyList.semigroup()).map(va, vb, fn).fix().toEither()
4

1 回答 1

6

假设我有一个类似于Validated被调用的数据类型ValRes

sealed class ValRes<out E, out A> {
    data class Valid<A>(val a: A) : ValRes<Nothing, A>()
    data class Invalid<E>(val e: E) : ValRes<E, Nothing>()
}

如果我有两个类型的值，ValRes并且我想将它们组合起来累积错误，我可以编写如下函数：

fun <E, A, B> tupled(
            a: ValRes<E, A>,
            b: ValRes<E, B>,
            combine: (E, E) -> E
        ): ValRes<E, Pair<A, B>> =
            if (a is Valid && b is Valid) valid(Pair(a.a, b.a))
            else if (a is Invalid && b is Invalid) invalid(combine(a.e, b.e))
            else if (a is Invalid) invalid(a.e)
            else if (b is Invalid) invalid(b.e)
            else throw IllegalStateException("This is impossible")
  • 如果两个值都是Valid我建立一对这两个值
  • 如果其中一个无效，我会得到一个Invalid具有单个值的新实例
  • 如果两者都无效，我使用该combine函数来构建Invalid包含这两个值的实例。

用法：

tupled(
    validateEmail("stojan"),    //invalid
    validateName(null)          //invalid
) { e1, e2 -> "$e1, $e2" }

这以通用方式工作，独立于类型 E、A 和 B。但它仅适用于两个值。我们可以为类型的 N 个值构建这样的函数ValRes。

现在回到箭头：

Validated.applicative<Nel<E>>(NonEmptyList.semigroup()).map(va, vb, fn).fix().toEither()

tupled类似于map（具有硬编码的成功功能）。va这里和我的例子类似vb。这里我们有一个自定义函数（），而不是返回一对值，它在成功的情况下组合两个值。abfn

结合错误：

interface Semigroup<A> {
  /**
   * Combine two [A] values.
   */
  fun A.combine(b: A): A
}

Semigroupin arrow 是一种将同一类型的两个值组合成同一类型的单个值的方法。类似于我的combine功能。NonEmptyList.semigroup()是给定两个列表的实现，Semigroup将NonEmptyList元素一起添加到单个NonEmptyList.

总结一下：

  • 如果两个值都是Valid-> 它将使用提供的函数将它们组合起来
  • 如果一个值是Valid和一个Invalid-> 返回错误
  • 如果两个值都是Invalid-> 使用Semigroup实例Nel来组合错误

在引擎盖下，这可以扩展到 2 到 X 值（我相信是 22）。

于 2020-04-30T19:00:39.637 回答