如何使用像`andThen`这样的运算符链接一般返回Either的链函数？

Question

问题： 链接多个 Either 返回函数，其中 Left 都是从公共密封特征 InternalError 继承的失败。但是，编译器抱怨 chain 正在返回 Either[_,Success] 而不是 Either[InternalError, Success]。

这是执行链接的代码：

import scala.language.implicitConversions
object EitherExtension {
  implicit class AndThenEither[A,B](val e: Function1[A,Either[_,B]]) {
    //get ability to chain/compose functions that return aligning Eithers
    def andThenE[C](f:Function1[B, Either[_,C]]): Function1[A, Either[_,C]] = {
      (v1: A) => e.apply(v1).flatMap(b => f.apply(b))
    }
  }
}

正如 cmets 中所指出的，这会丢弃 Left 的类型。如果我在下面更改它，它将无法正常工作，因为最终输出可以是Either[X|Y, C] 类型，它解析为Either[_,C]，我又回到了第一格。

implicit class AndThenEither[A,B,X](val e: (A) => Either[X, B]) {
    def andThenE[C,Y](f:(B) => Either[Y, C]): (A) => Either[_, C] = {
      (v1: A) => e.apply(v1).flatMap(b => f.apply(b))
    }
  }

这是显示类型对齐的组合失败的示例：

import EitherExtension._
object AndThenComposition {
  //sample type definitions of failure responses
  sealed trait InternalError
  case class Failure1() extends InternalError
  case class Failure2() extends InternalError
  //sample type definitions
  case class Id(id: Int)
  case class Stuff()
  //sample type definitions of successful responses
  case class Output1()
  case class Output2()
  case class InputRequest()

  val function1: (InputRequest) => Either[Failure1, Output1] = ???
  val function2: (Output1)  => Either[Failure2, Output2] = ???

  def doSomething(s:Id, l:List[Stuff]): Either[InternalError, Output2] = {
    val pipeline = function1 andThenE function2
    pipeline(InputRequest()) //Why is this of type Either[_, Output2]
  }
}

我错过了什么？我怎样才能让返回类型 not 是 Either[Any, Output2] 而是基本/密封特征？这可以通用吗？

Answer 1

您需要保留 left 的类型，因此我们将修改扩展方法来做到这一点。

请注意，由于两个 either 可以有不同的左类型，我们要做的是使用 type bound 要求编译器推断这些类型之间的 LUB；感谢Any，这总是可能的（虽然并不总是有帮助）。

object EitherExtension {
  implicit class AndThenEither[I, L1, R1](private val f: I => Either[L1, R1]) extends AnyVal {
    def andThenE[L2 >: L1, R2](g: R1 => Either[L2, R2]): I => Either[L2, R2] =
      i => f(i).flatMap(g)
  }
}

可以这样使用：

import EitherExtension._

object AndThenComposition {
  sealed trait InternalError
  final case object Failure1 extends InternalError
  final case object Failure2 extends InternalError

  val function1: Int => Either[Failure1.type, String] = ???
  val function2: String  => Either[Failure2.type, Boolean] = ???

  def doSomething(input: Int): Either[InternalError, Boolean] = {
    (function1 andThenE function2)(input)
  }
}

---

查看运行代码here。

Answer 2

如果您在生产中使用它，而且它不仅仅是一个学习的东西，您正在寻找的就是 Kleisli，幸运的是 cats-core 已经实现了它。

根据猫芯docs：

Kleisli 支持组合返回一元值的函数， 例如 Option[Int] 或 Either[String, List[Double]]，没有 让函数接受 Option 或 Either 作为参数，可以是 奇怪而笨拙。

由于 Kleisli 使用签名 A => F[B] 组合了两个函数，因此您只需要一个抽象即可使用 Kleisli，它为您的操作创建了一个新类型：

type Operation[A] = Either[InternalFailure, A]

通过这样做，您应该能够像这样使用 Kleisli：

import cats.data.Kleisli

val first: Kleisli[Operation, InputRequest, Output1] = Kleisli { request: InputRequest =>
  Left(Failure1())
}

val second: Kleisli[Operation, Output1, Output2] = Kleisli { output: Output1 =>
  Right(Output2())
}

val composed = first.andThen(second)