Scala 中的嵌套过滤器或者在 Future[Try[Int]] 之上

Question

I am beginner is scala , I am trying to implement a filter logic on top of a Either . Now I have a function getTaskId that returns Future[Try[Int]] and my filter logic is based on that Int . Now since filter expects boolean , I am unable to return the same in below code snippet .

val records: List[CommittableRecord[Either[Throwable, MyEvent]]] = ???
records.filter { 
  (x: CommittableRecord[Either[Throwable,MyEvent]]) => 
    x.value match {
      case Right(event: MyEvent) =>
        getTaskId(event.get("task").get) filter {
            case Success(value)     => value > 1
            case Failure(exception) => false
          }
      case Left(_) => false
    }
}

I am getting the error for filter on function getTaskId that returns Future[Try[Int]]

type mismatch;
 found   : scala.concurrent.Future[scala.util.Try[Int]]
 required: Boolean

So basically filter on top of Future returning another Future but the parent filter is expecting a boolean

Any help is greatly appreciated.

Answer 1

You faced two difficult features in scala here:

1. A lot of syntactic sugar
2. Best practice in scala is not awaiting Future s result inside you some business logic using: Await.result(future, timeout) . You should use it only at the end of the universe (in most cases: at the end of your program).

So, I would advice to refactor your current logic from having filtered List[CommittableRecord] in result to make result is non-blocking - Future[List[CommittableRecord]] with filtered list of records. You can work with this future, like it's just another data-container (like Option[T] ) and at the end of your program call blocking operation like Await.result .

Example of code:

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future.sequence
import scala.util.{Failure, Success, Try}

case class Task()

type MyEvent = Map[String, Task]
case class CommittableRecord(value: Either[Throwable, MyEvent])

def getTaskId(task: Task): Future[Try[Int]] = ???

val records: List[CommittableRecord] = List.empty[CommittableRecord]
val result: Future[List[CommittableRecord]] = sequence(
  records.map(
    x =>
      (x.value match {
        case Left(_) => Future(false)
        case Right(value) =>
          getTaskId(value.get("task").get)
            .map {
              case Failure(_) => false
              case Success(id) => id > 1
            }
      }).map(_ -> x)
  )
).map(
  idMoreThen1AndRecordList =>
    idMoreThen1AndRecordList.collect {
      case (true, record) => record
    }
)

or, after some refactoring and replacing lambda-expressions to functions:

def isTaskIdMoreThenOneAndRecord(record: CommittableRecord): Future[(Boolean, CommittableRecord)] =
  (record.value match {
    case Left(_) => Future(false)
    case Right(value) =>
      getTaskId(value.get("task").get)
        .map(tryId => tryId.fold(_ => false, _ > 1))
  }).map(_ -> record)

def filterRecordsWithTaskIdMoreThenOne(
    isMoreOneAndRecordList: List[(Boolean, CommittableRecord)]
): List[CommittableRecord] =
  isMoreOneAndRecordList.collect {
    case (true, record) => record
  }

val result: Future[List[CommittableRecord]] =
  sequence(records.map(isTaskIdMoreThenOneAndRecord))
    .map(filterRecordsWithTaskIdMoreThenOne)

So, in result you will have Future[List[CommittableRecord]] and you can work with filtered records using map function:

result.map((filteredRecords: List[CommittableRecord]) => \*do something with filtered records*\)

or you can compose two non-blocking operations (for example your list and another non-blocking function) using flatMap .

Useful links:

• read more about Future on scala documentation
• article about lambda expressions
• some best practices in scala concurrent