Lazy filter + flatMap + concat - scala

Question

What's the best way to do lazy transformations (without creating intermediate collections)
When
Doing a flatMap with filtering done both before and after the
flat map
Concatenating collections
Usually I use withFilter for such lazy filtering, but it doesn't quite work in the more complicated use cases
Filter + flatMap
1) Naive approach
case class Item(size: Int, color: String)
// Assume an order can have a lot of items
case class Orders(price:Int, country: String, items: Seq[C])
val orders: Seq[Orders]
val ca = orders.filter(_.country = "CA").flatMap(_.items).filter(_.size > 4)
val rest = orders.filter(_.country != "CA").flatMap(_.items).filter(_.size > 6)
val res = (ca ++ rest).filter(_.color == "red").take(100)
2) Single path, but intermediate collections of items are created for each order. And I think flatMap also produces a collection
orders.flatMap {
case order if order.country = "CA") => order.items.filter(_.size > 4)
case order => order.items
}.withFilter(_.color == "red").take(100)
3) Iterators. But I am not 100% sure how exactly it is going get executed
orders.iterator.flatMap {
case order if order.country = "CA") => order.items.iterator.filter(_.size > 4)
case order => order.items.iterator
}.filter(_.color == "red").take(100)
4) Stream.
orders.toStream.flatMap {
case order if order.country = "CA") => order.items.toStream.filter(_.size > 4)
case order => order.items.toStream
}.filter(_.color == "red").take(100)
5) Views: Not sure if an intermediate collection will be created for the items in each order (I think it will), and also in general I am not a fan of views (forgetting "force" can lead to bugs)
orders.view.flatMap {
case order if order.country = "CA") => order.items.filter(_.size > 4)
case order => order.items
}.filter(_.color == "red").take(100)
Concat
Similar options, but for
val items1 = items.filter(filter1)
val items2 = items.filter(filter2)
val items3 = items.filter(filter3)
val res = (items1 ++ items2 ++ items3).filter(_.color == "Red").take(100)

Answer 1

Is the solution just to noramlize the classes? In your example you essentially have a nested sequence and to go from nested to one sequence you would need to flatten at some point.
A solution could be a List[Tuple2[Order, Item]] with item removed from Order.
That way you can do one collect.
For eaxmple:
object Main {
case class Item(size: Int, color: String)
case class Order(price:Int, country: String)
def main(args: Array[String]): Unit = {
val orders: Seq[Tuple2[Order, Item]] = Seq(Order(0, "CA") -> Item(5, "red"), Order(0, "GB")-> Item(1, "blue"))
val filtered: Seq[Item] = orders.collect {
case (order, item) if order.country == "CA" && item.size > 4 && item.color == "red" => item
}
println(orders)
println(filtered)
}
}
// Output:
// List((Order(0,CA),Item(5,red)), (Order(0,GB),Item(1,blue)))
// List(Item(5,red))
Try it online!