Blog Post - Composing Future. List and Either: code snippets

Blog_post-Composing_Future,_List_and_Either.md

Code snippets used in blog post "Composing Future, List and Either": https://pbassiner.github.io/blog/composing_future,_list_and_either.html

Compose.scala

def getCommitsWithAuthor(): Future[Either[Error, List[CommitAndAuthor]]] = ???

EitherT.scala

/**
 * Transformer for `Either`, allowing the effect of an arbitrary type constructor `F` to be combined with the
 * fail-fast effect of `Either`.
 *
 * `EitherT[F, A, B]` wraps a value of type `F[Either[A, B]]`. An `F[C]` can be lifted in to `EitherT[F, A, C]` via `EitherT.right`,
 * and lifted in to a `EitherT[F, C, B]` via `EitherT.left`.
 */
final case class EitherT[F[_], A, B](value: F[Either[A, B]]) {
  ...
}

FirstApproach.scala

def getCommitsWithAuthor(): Future[Either[Error, List[CommitAndAuthor]]] =
  getCommits() flatMap {
    case Right(commits) => sequence(listCommitsAndAuthor(commits)) map { list =>
      list.foldLeft(
        Right[Error, List[CommitAndAuthor]](List.empty).asInstanceOf[Either[Error, List[CommitAndAuthor]]]
      )(
        (acc, x) => x match {
          case Right(value) => acc.map(list => list :+ value)
          case Left(err) => acc.left.map(_ => err)
        }
      )
    }
    case Left(e) => Future.successful(Left(e))
  }

FirstApproachExpanded.scala

def getCommitsWithAuthor(): Future[Either[Error, List[CommitAndAuthor]]] =
  getCommits() flatMap {
    case Right(commits) => sequence(
      commits =>
        commits map { commit =>
          getAuthor(commit.id) map { either =>
            either map { author =>
              CommitAndAuthor(commit, author)
            }
          }
        }
    ) map { list =>
      list.foldLeft(
        Right[Error, List[CommitAndAuthor]](List.empty).asInstanceOf[Either[Error, List[CommitAndAuthor]]]
      )(
        (acc, x) => x match {
          case Right(value) => acc.map(list => list :+ value)
          case Left(err) => acc.left.map(_ => err)
        }
      )
    }
    case Left(e) => Future.successful(Left(e))
  }

FirstApproachFold.scala

sequence(listCommitsAndAuthor(commits)) map { list =>
  list.foldLeft(
    Right[Error, List[CommitAndAuthor]](List.empty).asInstanceOf[Either[Error, List[CommitAndAuthor]]]
  )(
    (acc, x) => x match {
      case Right(value) => acc.map(list => list :+ value)
      case Left(err) => acc.left.map(_ => err)
    }
  )
}

FirstApproachInner.scala

def listCommitsAndAuthor: List[Commit] => List[Future[Either[Error, CommitAndAuthor]]] =
  commits =>
    commits map { commit =>
      getAuthor(commit.id) map { either =>
        either map { author =>
          CommitAndAuthor(commit, author)
        }
      }
    }

FirstApproachSequence.scala

sequence(listCommitsAndAuthor(commits))

GithubApi.scala

def getCommits(): Future[Either[Error, List[Commit]]]
def getAuthor(commitId: String): Future[Either[Error, Author]]

Model.scala

final case class Commit(id: String)
final case class Author(id: String)
final case class CommitAndAuthor(commit: Commit, author: Author)

SecondApproach.scala

import cats.data.EitherT
import cats.instances.future._
import cats.instances.list._
import cats.syntax.traverse._

def getCommitsWithAuthor(): Future[Either[Error, List[CommitAndAuthor]]] =
  (for {
    commits <- EitherT(getCommits())
    result <- commits.map { commit =>
      EitherT(getAuthor(commit.id)) map { author => CommitAndAuthor(commit, author) }
    }.sequenceU
  } yield result).value

SecondApproachInner.scala

import cats.data.EitherT
import cats.instances.future._

implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global

commits.map { commit =>
  EitherT(getAuthor(commit.id)) map { author => CommitAndAuthor(commit, author) }
}

SecondApproachTraverse.scala

import cats.data.EitherT
import cats.instances.list._
import cats.instances.future._
import cats.syntax.traverse._

implicit val ec: ExecutionContext = scala.concurrent.ExecutionContext.Implicits.global

commits.map { commit =>
  EitherT(getAuthor(commit.id)) map { author => CommitAndAuthor(commit, author) }
}.sequenceU