scala - エラーまたはトラバースを蓄積するために、EitherT と Validation を切り替える

Question

次の機能があるとします。

def getRemoteThingy(id: Id): EitherT[Future, NonEmptyList[Error], Thingy]

を指定すると、次を使用してList[Id]簡単に取得できます。List[Thingy]Traverse[List]

val thingies: EitherT[Future, NonEmptyList[Error], List[Thingy]] = 
  ids.traverseU(getRemoteThingy)

ベースとなるApplicativeインスタンスを使用するため、最初の のみを取得し、すべてを追加するわけではありません。あれは正しいですか？EitherTflatMapNonEmptyList[Error]

EitherTここで、実際にエラーを累積したい場合は、とを切り替えることができValidationます。例えば：

def thingies2: EitherT[Future, NonEmptyList[Error], List[Thingy]] = 
  EitherT(ids.traverseU(id => getRemoteThingy(id).validation).map(_.sequenceU.disjunction))

それは機能し、最後にすべてのエラーが表示されますが、かなり面倒です。コンポジションを使用して簡単にすることができます。Applicative

type ValidationNelError[A] = Validation[NonEmptyList[Error], A]
type FutureValidationNelError[A] = Future[ValidationNelError[A]]
implicit val App: Applicative[FutureValidationNelError] =
  Applicative[Future].compose[ValidationNelError]

def thingies3: EitherT[Future, NonEmptyList[Error], List[Thingy]] = 
  EitherT(
    ids.traverse[FutureValidationNelError, Thingy](id => 
      getRemoteThingy(id).validation
    ).map(_.disjunction)
  )

他のものよりも長くなりますが、すべての配管はコード ベース全体で簡単に共有できます。

私のソリューションについてどう思いますか? この問題を解決するよりエレガントな方法はありますか? 普段はどのように対処していますか？

どうもありがとうございました。

編集：

pimp への自然な変換を使用した一種の狂人のソリューションがありTraversableます。それを機能させるには、明らかにタイプエイリアスが必要です。そのため、再定義しましたgetRemoteThingy：

type FutureEitherNelError[A] = EitherT[Future, NonEmptyList[String], A]

def getRemoteThingy2(id: Id): FutureEitherNelError[Thingy] = getRemoteThingy(id)

implicit val EitherTToValidation = new NaturalTransformation[FutureEitherNelError, FutureValidationNelError] {
  def apply[A](eitherT: FutureEitherNelError[A]): FutureValidationNelError[A] = eitherT.validation
}

implicit val ValidationToEitherT = new NaturalTransformation[FutureValidationNelError, FutureEitherNelError] {
  def apply[A](validation: FutureValidationNelError[A]): FutureEitherNelError[A] = EitherT(validation.map(_.disjunction))
}

implicit class RichTraverse[F[_], A](fa: F[A]) {
  def traverseUsing[H[_]]: TraverseUsing[F, H, A] = TraverseUsing(fa)
}

case class TraverseUsing[F[_], H[_], A](fa: F[A]) {
  def apply[G[_], B](f: A => G[B])(implicit GtoH: G ~> H, HtoG: H ~> G, A: Applicative[H], T: Traverse[F]): G[F[B]] =
    HtoG(fa.traverse(a => GtoH(f(a))))
}

def thingies4: FutureEitherNelError[List[Thingy]] = 
  ids.traverseUsing[FutureValidationNelError](getRemoteThingy2)