Monadic short-circuiting in Akka Streams

Question

I'd like to chain a series of Flow's of the form a -> Try[b], where each successive stage handles the Success case of the previous, and the Sink at the end handles all Failure generically.

Can this or something equivalent be encoded succinctly? It's actually a linear flow, but I'm not sure how short of broadcasting and merging at every stage.

Answer 1

One way of solving this is to define a fan-out stage partitioning the Try into 2 streams, depending on its outcome

  object PartitionTry {
    def apply[T]() = GraphDSL.create[FanOutShape2[Try[T], Throwable, T]]() { implicit builder ⇒
      import GraphDSL.Implicits._

      val success = builder.add(Flow[Try[T]].collect { case Success(a) ⇒ a })
      val failure = builder.add(Flow[Try[T]].collect { case Failure(t) ⇒ t })
      val partition = builder.add(Partition[Try[T]](2, _.fold(_ ⇒ 0, _ ⇒ 1)))

      partition ~> failure
      partition ~> success

      new FanOutShape2[Try[T], Throwable, T](partition.in, failure.out, success.out)
    }
  }

Then your generic flow can ingest Trys and send the Failures to a sink of choice, whilst passing the Successes on

  object ErrorHandlingFlow {
    def apply[T, MatErr](errorSink: Sink[Throwable, MatErr]): Flow[Try[T], T, MatErr] = Flow.fromGraph(
      GraphDSL.create(errorSink) { implicit builder ⇒ sink ⇒
        import GraphDSL.Implicits._

        val partition = builder.add(PartitionTry[T]())

        partition.out0 ~> sink

        new FlowShape[Try[T], T](partition.in, partition.out1)
      }
    )
  }

usage example below

  val source      : Source[String, NotUsed]           = Source(List("1", "2", "hello"))
  val convert     : Flow[String, Try[Int], NotUsed]   = Flow.fromFunction((s: String) ⇒ Try{s.toInt})
  val errorsSink  : Sink[Throwable, Future[Done]]     = Sink.foreach[Throwable](println)
  val handleErrors: Flow[Try[Int], Int, Future[Done]] = ErrorHandlingFlow(errorsSink)

  source.via(convert).via(handleErrors).runForeach(println)

Note that

• the 2 stages defined above are reusable for any type (write once, use everywhere)
• this approach can be reused for other type classes - like Either, etc.