Scala, Either[_, Seq[Either[_, T]] to Either[_, Seq[T]] - scala

Question

Here's the scaste for the code below: https://scastie.scala-lang.org/bQMGrAKgRoOFaK1lwCy04g
I've a two JSON API endpoints. First, items.cgi, returns list of item objects in the following format
$ curl http://example.com/items.cgi
[
...
{ sn: "KXB1333", ownerId: 3, borrowerId: 0 },
{ sn: "KCB1200", ownerId: 1, borrowerId: 2 },
...
]
borrowerId == 0 means item has no borrower.
Second, users.cgi, returns user specified by id query parameter
$ curl http://example.com/user.cgi?id=1
{ id: 1, name: "frank" }
The API may be bad but I have to deal with it. Now in Scala I'd like to work with this nice data model
case class User(id: Int, name: String)
case class Item(sn: String, owner: User, borrower: Option[User])
I also have the following for doing HTTP requests
case class ApiFail(reason: String)
def get[T](url: String): Either[ApiFail, T] = ??? /* omitted for brevity */
The get() function uses some magic to fetch a JSON from an URL and construct a T out of it (it uses some libraries). On IO failure or bad HTTP status it returns Left.
I'd like to write the following function
def getItems: Either[ApiFail, Seq[Item]]
It should fetch the list of items, for each item fetch the linked users and return a new list of Items or fail on any HTTP request failure. (There may be redundant requests for users with a same ID but I don't care about memoization/caching yet.)
So far I only managed to write this function
def getItems: Either[ApiFail, Seq[Either[ApiFail, Item]]]
where a failure to retrieve some user is fatal only for the corresponding item and not the whole result. Here's the implementation
def getItems: Either[ApiFail, Seq[Either[ApiFail, Item]]] = {
case class ItemRaw(sn: String, ownerId: Int, borrowerId: Int)
get[List[ItemRaw]]("items.cgi").flatMap(itemRawList => Right(
itemRawList.map(itemRaw => {
for {
owner <- get[User](s"users.cgi?id=${itemRaw.ownerId}")
borrower <-
if (itemRaw.borrowerId > 0)
get[User](s"users.cgi?id=${itemRaw.borrowerId}").map(Some(_))
else
Right(None)
} yield
Item(itemRaw.sn, owner, borrower)
})
))
}
This seems like a request for a homework but it occurs to me frequently that I want to switch from one wrapper thing (m-monad?) to another and I'm a bit puzzled as to how to do it with wrapper functions (c-combinators?) only. I could of course switch to an imperative implementation. I'm just curious.

Answer 1

There is a word for doing exactly this in the FP world - "Traverse" (link to cats implementation). It's used when you have an F[A] and a function A => G[B] and you want a G[F[B]]. Here, F is List, A is ItemRaw, G is Either[ApiFail, _], and B is Item. Of course there are some constraints on what F and G can be.
Using cats, you can change your method very slightly:
import cats._, cats.implicits._
def getItems: Either[ApiFail, Seq[Item]] = {
case class ItemRaw(sn: String, ownerId: Int, borrowerId: Int)
get[List[ItemRaw]]("items.cgi").flatMap(itemRawList =>
itemRawList.traverse[({type T[A]=Either[ApiFail, A]})#T, Item](itemRaw => {
for {
owner <- get[User](s"users.cgi?id=${itemRaw.ownerId}")
borrower <-
if (itemRaw.borrowerId > 0)
get[User](s"users.cgi?id=${itemRaw.borrowerId}").map(Some(_))
else
Right(None)
} yield
Item(itemRaw.sn, owner, borrower)
})
)
}
With that said, I can certainly understand being hesitant to go fully down that route. cats (and scalaz) are a lot to take in - though I recommend you do at some point!
Without them, you can always write your own utility methods for manipulating your commonly-used containers:
def seqEither2EitherSeq[A, B](s: Seq[Either[A, B]]): Either[A, Seq[B]] = {
val xs: Seq[Either[A, Seq[B]]] = s.map(_.map(b => Seq(b)))
xs.reduce{ (e1, e2) => for (x1 <- e1; x2 <- e2) yield x1 ++ x2 }
}
def flattenEither[A, B](e: Either[A, Either[A, B]]): Either[A, B] = e.flatMap(identity)
Then the result you want would be:
val result: Either[ApiFail, Seq[Item]] = flattenEither(getItems.map(seqEither2EitherSeq))