Scala - concatenate number of Try() results - scala

Question

I have number of interfaces where each one of the returns Try() result.
For example:
def getElements1(id: Guid): Try[Seq[SpecialElement]] //From interface A
def getElements2(id: Guid): Try[Seq[SpecialElement]] //From interface B
def getElements3(id: Guid): Try[Seq[SpecialElement]] //From interface C
The all independent and can fail randomly.
What is the nicest 'Scala way' to concatenate their output with respect to Failure() case as well?

Answer 1

Well... nicest 'Scala way' depends on what your requirements are ?
So... you have following 3 defs,
def getElements1(id: Guid): Try[Seq[SE]]
def getElements2(id: Guid): Try[Seq[SE]]
def getElements3(id: Guid): Try[Seq[SE]]
Case 1 - The result fails, if at least 1 of them fails and you get the error of only 1 failure.
val result: Try[Seq[SE]] = for {
emements1 <- getElements1(id)
emements2 <- getElements2(id)
emements3 <- getElements3(id)
} yield emements1 ++ emements2 ++ emements3
Case 2 - The result fails, if at least 1 of them fails and you want to get the errors of all failures,
def trySeqToEither[T](tryTSeq: Seq[Try[T]]): Either[Seq[Throwable], Seq[T]] = {
val accInit: Either[Seq[Throwable], Seq[T]] = Right(Seq.empty[T])
tryTSeq.aggregate(accInit)({
case (Right(seq), Success(t)) => Right(seq :+ t)
case (Right(seq), Failure(ex)) => Left(Seq[Throwable](ex))
case (Left(seq), Success(t)) => Left(seq)
case (Left(seq), Failure(ex)) => Left(seq :+ ex)
})
}
val seqResultEither: Either[Seq[Throwable], Seq[Seq[SE]]] = trySeqToEither(
Seq(getElements1(id), getElements2(id), getElements3(id))
)
val resultEither: Either[Seq[Throwable], Seq[SE]] = seqResultEither match {
case Right(seqResult) => Right(seqResult.flatten)
case Left(seqThrowable) => Left(seqThrowable)
}
Case 3 - The result ignores the failed computations
val emementsOption1 = getElements1(id).toOption
val emementsOption1 = getElements2(id).toOption
val emementsOption3 = getElements3(id).toOption
val result: Seq[SE] = Seq[Seq[SE]](emementsOption1, emementsOption2, emementsOption3).flatten

Answer 2

You can use for comprehensions:
case class SpecialElement(x: Int)
val x: Try[Seq[SpecialElement]] = Try(List(SpecialElement(1)))
val y: Try[Seq[SpecialElement]] = Try(List(SpecialElement(2)))
val z: Try[Seq[SpecialElement]] = Try(List(SpecialElement(3)))
for {
a <- x
b <- y
c <- z
} yield a ++ b ++ c
Success(List(SpecialElement(1), SpecialElement(2), SpecialElement(3)))
for {
a <- x
b <- y
c <- Try(throw new Exception)
} yield a ++ b ++ c
Failure(java.lang.Exception)