Unwrapping the Functions without parameters in scala with Futures - scala

Question

I'm trying to create a transformation chain to define possible transformations for given functions:
type Transformation[T] = T => Future[T]
def transformationChain[T](chain: Seq[Transformation[T]]): Transformation[T] = {
}
val t1: Transformation[Int] = t => Future.successful(t + t)
val t2: Transformation[Int] = _ => Future.failed(new NoSuchElementException)
val t3: Transformation[Int] = t =>
if (t > 2) Future.successful(t * t)
else Future.failed(new NoSuchElementException)
val tc = transformationChain(Seq(t1, t2, t2, t3))
val tc2 = transformationChain(Seq(t2, t2, t2))
val tc3 = transformationChain(Seq(t2, t3, t1))
println(Await.result(tc(2), 5.seconds)) // 16
println(Await.result(tc2(2), 5.seconds)) // throw NoSuchElementException
println(Await.result(tc3(2), 5.seconds)) // 4
The problem is that I don't understand how to unwrap these functions in "transformationChain" method to send the result to every next function in the chain by calling them in the loop or recursively.

Answer 1

What you're described as Transformation (so function of A => F[B]) is called often Kleisli arrows.
Cats library has a data type, that makes operation on these kinds of functions easier. For example, it has a method andThen which allows the composition of these functions:
import cats.data.Kleisli
import cats.implicits._
val t1: Transformation[Int] = t => Future.successful(t + t)
val t2: Transformation[Int] = _ => Future.failed(new NoSuchElementException)
Kleisli(t1).andThen(Kleisli(t2))
The only problem is, that one of your transformations could return the failed future, which would short-circuit the whole chain. We can fix it with recoverWith.
So finally transformationChain could look like:
def transformationChain[T](chain: Seq[Transformation[T]]): Transformation[T] =
t =>
chain
//wrap the function in Kleisli and then use replace failed futures with succeeded
//future, that are passing value over
.map(Kleisli(_).recoverWith {
case _ => Kleisli(x => Future.successful(x))
})
.reduce(_ andThen _) //combine all elements with andThen
.apply(t)
It works fine for case 1 and 3 but fails for case 2 since it will just return passed value.
println(Await.result(tc(2), 5.seconds)) // 16
println(Await.result(tc3(2), 5.seconds)) // 4
println(Await.result(tc2(2), 5.seconds)) // 2

Answer 2

import scala.concurrent.{ ExecutionContext, Future }
import scala.util.Try
import ExecutionContext.Implicits.global
object Transformations {
type Transformation[T] = T => Future[T]
private object DummyException extends Exception
private val notReallyAFailedFuture: Future[Throwable] = Future.failed(DummyException)
def transformationChain[T](chain: Seq[Transformation[T]])(implicit ectx: ExecutionContext): Transformation[T] = t =>
if (chain.nonEmpty) {
val initialFut = Future.successful(t)
// resultFut will succeed if any of the transformations in the chain succeeded
// lastFailure will fail if all of the transformations succeeded, otherwise it has the last failure
val (resultFut: Future[T], lastFailure: Future[Throwable]) =
chain.foldLeft((Future.failed[T](DummyException), notReallyAFailedFuture)) { (acc, v) =>
val thisResult = acc._1.recoverWith {
case _ => initialFut
}.flatMap(v)
val lastFailure = thisResult.failed.recoverWith { case _ => acc._2 }
(thisResult.recoverWith { case _ => acc._1 }, lastFailure)
}
resultFut.recoverWith {
case _ =>
lastFailure.flatMap(Future.failed)
}
} else Future.successful(t) // What to do with an empty chain is unspecified
def main(args: Array[String]): Unit = {
import scala.concurrent.Await
import scala.concurrent.duration._
val t1: Transformation[Int] = t => Future.successful(t + t)
val t2: Transformation[Int] = _ => Future.failed(new NoSuchElementException)
val t3: Transformation[Int] = t =>
if (t > 2) Future.successful(t * t)
else Future.failed(new NoSuchElementException)
val tc1 = transformationChain(Seq(t1, t2, t2, t3))
val tc2 = transformationChain(Seq(t2, t2, t2))
val tc3 = transformationChain(Seq(t2, t3, t1))
println(Try(Await.result(tc1(2), 5.seconds)))
println(Try(Await.result(tc2(2), 5.seconds)))
println(Try(Await.result(tc3(2), 5.seconds)))
}
}
This implementation assumes that:
If multiple transformations fail, return the last failure
If the chain is empty, assume an identity transformation
transformationChain does now require an implicit ExecutionContext for scheduling the "glue" functions between the transformation futures. In Scala 2.13+, the scala.concurrent.ExecutionContext.parasitic context is actually a pretty good choice for executing these quick transformations (and is useful for basically nothing else).
In order to get all the printlns to execute, I've wrapped the Await.results in Try.
In the interest of brevity, there's some use of a failed Future to represent absence of a result.