"conditionalZip" operator in Akka Streams - scala

Question

Assume that I have two sources:
val first = Source(1 :: 2 :: 4 :: 6 :: Nil)
val second = Source(1 :: 2 :: 3 :: 4 :: 5 :: 6 :: 7 :: Nil)
Is it possible to create a zip that will pair only elements based on a condition? I mean something like:
first.conditionalZip(second, _ == _) // if that method exited
That code would take the element from the first source and drop elements from the second until there is an element that satisfies the condition, and then output a tuple. The result for the above call would be (1, 1), (2, 2), (4, 4), (6, 6).

Answer 1

Consider zipping the two Sources, followed by using statefulMapConcat to transform the zipped elements in accordance with the condition function, as shown below:
import akka.stream.scaladsl._
import akka.NotUsed
def popFirstMatch(ls: List[Int], condF: Int => Boolean): (Option[Int], List[Int]) = {
ls.find(condF) match {
case None =>
(None, ls)
case Some(e) =>
val idx = ls.indexOf(e)
if (idx < 0)
(None, ls)
else {
val (l, r) = ls.splitAt(idx)
(r.headOption, l ++ r.tail)
}
}
}
def conditionalZip( first: Source[Int, NotUsed],
second: Source[Int, NotUsed],
filler: Int,
condFcn: (Int, Int) => Boolean ): Source[(Int, Int), NotUsed] = {
first.zipAll(second, filler, filler).statefulMapConcat{ () =>
var prevList = List.empty[Int]
tuple => tuple match { case (e1, e2) =>
if (e2 != filler) {
if (e1 != filler && condFcn(e1, e2))
(e1, e2) :: Nil
else {
if (e1 != filler)
prevList :+= e1
val (opElem, rest) = popFirstMatch(prevList, condFcn(_, e2))
prevList = rest
opElem match {
case None => Nil
case Some(e) => (e, e2) :: Nil
}
}
}
else
Nil
}
}
}
Test running:
import akka.actor.ActorSystem
implicit val system = ActorSystem("system")
implicit val ec = system.dispatcher
// Example 1:
val first = Source(1 :: 2 :: 4 :: 6 :: Nil)
val second = Source(1 :: 2 :: 3 :: 4 :: 5 :: 6 :: 7 :: Nil)
conditionalZip(first, second, Int.MinValue, _ == _).runForeach(println)
// (1,1)
// (2,2)
// (4,4)
// (6,6)
conditionalZip(first, second, Int.MinValue, _ > _).runForeach(println)
// (4,3)
// (6,4)
conditionalZip(first, second, Int.MinValue, _ < _).runForeach(println)
// (1,2)
// (2,3)
// (4,5)
// (6,7)
// Example 2:
val first = Source(3 :: 9 :: 5 :: 5 :: 6 :: Nil)
val second = Source(1 :: 3 :: 5 :: 2 :: 5 :: 6 :: Nil)
conditionalZip(first, second, Int.MinValue, _ == _).runForeach(println)
// (3,3)
// (5,5)
// (5,5)
// (6,6)
conditionalZip(first, second, Int.MinValue, _ > _).runForeach(println)
// (3,1)
// (9,3)
// (5,2)
// (6,5)
conditionalZip(first, second, Int.MinValue, _ < _).runForeach(println)
// (3,5)
// (5,6)
A few notes:
Method zipAll (available on Akka Stream 2.6+) zips the two Sources while padding the one with fewer elements with provided "filler" values. In this case, these fillers are of no interest hence should be assigned a distinct value from actual elements.
An internal List, prevList, is used within statefulMapConcat to store elements from the 1st Source for comparing in following iterations with elements from the 2nd Source. The List can be replaced with a Set for better lookup performance if elements within the Sources are distinct.
Method popFirstMatch is for extracting the first element in the prevList that matches the provided partial condition function, returning a Tuple of the element of type Option and the remaining List.
NOTE that this is just an illustration of how statefulMapConcat may be a solution for the described problem. Behavior of the sample code may not necessarily match the exact requirement without detailed implementation to either cover all cases or refine the scope of the fairly broad condition function (Int, Int) => Boolean.