Break loop if Either function returns Left - scala

Question

In the following code, what I need is to stop processing the loop if either either1 or either2 return Left, and if that happens then mainFunction has to return Left as well. Also, the string returned by either1.Left or either2.Left needs to be returned by mainFunction.Left. How to make this work?
def either1 (i:Int): Future[Either[String,Int]] = Future {
if (i<3)
Right(i*2)
else
Left("error 1")
}
def either2 (i:Int): Future[Either[String,Int]] = Future {
if (i>3)
Right(i*2)
else
Left("error 2")
}
val seq = Seq ( 1,1,2,2,3,4,5 )
def mainFunction: Future[Either[String,Int]] = Future {
val seq2 = seq.map { number =>
if (number % 2 == 0)
either1(number) // <-- this needs to break the loop if it returns Left
else
either2(number) // <-- this needs to break the loop if it returns Left
}
Right(seq2.length) // <-- seq2 is a sequence of Futures
}

Answer 1

The code below keeps iterating over the sequence until it encounters the first error, and returns the error message, or the fixed number 42 (that's the "doesn't matter what it returns"-requirement).
import scala.concurrent._
import scala.util._
import scala.concurrent.ExecutionContext.Implicits.global
def either1(i: Int): Future[Either[String,Int]] = Future {
if (i < 3) Right(i * 2)
else Left("error 1")
}
def either2 (i:Int): Future[Either[String,Int]] = Future {
if (i > 3) Right(i * 2)
else Left("error 2")
}
val seq = Seq(1, 1, 2, 2, 3, 4, 5)
val doesntMatter = 42
/** Returns either first error message returned by `either1` or
* `either2`, or the fixed number `doesntMatter`.
*/
def mainFunction: Future[Either[String, Int]] = {
def recHelper(remaining: List[Int]): Future[Either[String, Int]] = {
remaining match {
case Nil => Future { Right(doesntMatter) }
case h :: t => (if (h % 2 == 0) either1(h) else either2(h)).flatMap {
headEither =>
headEither match {
case Left(s) => Future { Left(s) }
case Right(n) => recHelper(t)
}
}
}
}
recHelper(seq.toList)
}
val res = mainFunction
Thread.sleep(2000)
println(res) // Future(Success(Left(error 2)))
If you do this significantly more often than once, consider taking a look at Scala Cats' EitherT, and also at the method tailRecM defined specifically for such use cases on all monadic typeclasses.

Answer 2

In Scala the standard collections don’t provide a method for that.
You can user either scala.util.control.Breaks or you have to write the
recursion, something like this
val seq = Seq(1, 1, 2, 2, 3, 4, 5)
def either1(i: Int): Either[String, Int] = {
if (i < 3) Right(i * 2)
else Left("error 1")
}
def either2(i: Int): Either[String, Int] = {
if (i > 3) Right(i * 2)
else Left("error 2")
}
def rec(seq: Seq[Int], acc: Seq[Either[String, Int]]): Seq[Either[String, Int]] = seq match {
case Nil => acc
case x :: xs =>
val xx = if (x % 2 == 0) either1(x) else either2(x)
xx match {
case Left(_) => acc
case Right(value) => rec(xs, acc :+ Right(value))
}
}
rec(seq, Seq())

Answer 3

I generally avoid recursive functions if a library function will do what I want.
In this case we can use takeWhile to take all the leading elements that are Right. However the map call will still process every element of the Seq so you need to use view to evaluate this lazily:
val seq2 = seq.view.map { number =>
if (number % 2 == 0)
either1(number)
else
either2(number)
}.takeWhile(_.isRight)
You still have the the problem that your either functions actually return a Future and therefore can't be tested for Left or Right until they complete.