How to use transformWith() to ignore failed futures?

user_5795392 0
Viewed 528

I need to process sequence of transformations into one transformation, in order to if I have some failed Future it should be just ignored(I am trying to do it without recover or recoverWith, but smth going wrong, code fails when meet any failure)

type Transformation[T] = T => Future[T]
//in - Seq(trans1, trans2, trans3)

in.reduce[Transformation[T]](
  (acc, el) =>
    acc.andThen[Future[T]](
      ft =>
        ft.flatMap(el)
          .transformWith[T](
            t =>
              t match {
                case Failure(exception) => ft //this line is the most suspicious for me
                case Success(value)     => Future.successful(value)
              }
          )
    )
)
future scala
1 Answers

The transformWith doesn't seem to provide you the possibility to recover with the original input value from the previous step, because it has to work with a Try. What is it supposed to do if the Try turns out to be a failure? By that time, it does not have the original input to fall back to, it only has a Throwable, not a T. So, transformWith seems insufficient.

If the pipeline is just a few transformations long, you can try foldLeft with fallbackTo:

import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

type Transformation[T] = T => Future[T]
def chainTrafos[T](
  trafos: List[Transformation[T]],
  value: T
): Future[T] = {
  trafos.foldLeft(Future { value })(
    (f, t) => f.flatMap(x => t(x).fallbackTo(Future { x }))
  )
}


val ta: Transformation[Int] = x => Future { x * x }
val tb: Transformation[Int] = x => Future.failed(new Error("oops"))
val tc: Transformation[Int] = x => Future { x - 58 }

println(Await.result(chainTrafos(List(ta, tb, tc), 10), 10.seconds))

prints

42
user_27077920
Related