From method fetchDiagnosisForUniqueCodes, I would like to return Future[List[DiagnosisCode]]

Question

// This is my requirement

// getAllUniqueCodes codes,

// map over getAllUniqueCodes and then

// call fetchDiagnosisForUniqueCode that returns Future[List[DiagnosisCode]]

case class DiagnosisCode(rootCode: String, uniqueCode: String, description: Option[String] = None)

object Database {

private val data: List[DiagnosisCode] = List(

DiagnosisCode("A00", "A001", Some("Cholera due to Vibrio cholerae")),

DiagnosisCode("A00", "A009", Some("Cholera, unspecified")),

DiagnosisCode("A08", "A080", Some("Rotaviral enteritis")),

DiagnosisCode("A08", "A083", Some("Other viral enteritis")),

DiagnosisCode("B15", "B150", Some("Hepatitis A with hepatic coma")),

DiagnosisCode("B15", "B159", Some("Hepatitis A without hepatic coma")),

DiagnosisCode("H26", "H26001", Some("Other cataract right eye")),

DiagnosisCode("H26", "H26002", Some("Other cataract left eye"))

)

def getAllUniqueCodes: Future[List[String]] = Future {

Database.data.map(_.uniqueCode)

}

def fetchDiagnosisForUniqueCode(uniqueCode: String): Future[Option[DiagnosisCode]] = Future {

Database.data.find(_.uniqueCode.equalsIgnoreCase(uniqueCode))

}

}

// ------Kindly find the problem below---------------------

PlainBashC++C#CSSDiffHTML/XMLJavaJavascriptMarkdownPHPPythonRubySQL

def fetchDiagnosisForUniqueCodes/*: Future[List[DiagnosisCode]]*/ = {

Database.getAllUniqueCodes.map { (xs: List[String]) =>

xs.map { (uq: String) =>

Database.fetchDiagnosisForUniqueCode(uq)

}

}

}

Answer 1

The problem is that your current implementation returns Future[List[Future[Option[DiagnosisCode]]]]. You're mapping inside a Future and then mapping again, creating nested futures.

To get Future[List[DiagnosisCode]] , use flatMap and Future.sequence to flatten (removes nested behavior).

def fetchDiagnosisForUniqueCodes: Future[List[DiagnosisCode]] = {

Database.getAllUniqueCodes.flatMap { (xs: List[String]) =>

val futures: List[Future[Option[DiagnosisCode]]] = xs.map { (uq: String) =>

Database.fetchDiagnosisForUniqueCode(uq)

}

Future.sequence(futures).map { (results: List[Option[DiagnosisCode]]) =>

results.flatten

}

}

}

Here's what each part does:

1. flatMap instead of map on the outer Future — so you can return another Future from inside without nesting
2. Future.sequence — converts List[Future[Option[DiagnosisCode]]] into Future[List[Option[DiagnosisCode]]], running all the lookups
3. .flatten — collapses List[Option[DiagnosisCode]] into List[DiagnosisCode], dropping any None results (codes not found)