I am not able to return Future[List[DiagnosisCode]] from fetchDiagnosisForUniqueCodes

import scala.concurrent._
import ExecutionContext.Implicits.global  
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"))
      )
    
      def getAllUniqueCodes: Future[List[String]] = Future {
        Database.data.map(_.uniqueCode)
      }


      def fetchDiagnosisForUniqueCode(uniqueCode: String): Future[Option[DiagnosisCode]] = Future {
        Database.data.find(_.uniqueCode.equalsIgnoreCase(uniqueCode))
      }
    }

getAllUniqueCodes returns all unique codes from data List.

fetchDiagnosisForUniqueCode returns DiagnosisCode when uniqueCode matches.

• From fetchDiagnosisForUniqueCodes, I would like to return Future[List[DiagnosisCode]] using getAllUniqueCodes() and fetchDiagnosisForUniqueCode(uniqueCode).*

    def fetchDiagnosisForUniqueCodes: Future[List[DiagnosisCode]] = {
  
      val xa: Future[List[Future[DiagnosisCode]]] = Database.getAllUniqueCodes.map { (xs: 
          List[String]) =>
        xs.map { (uq: String) =>
          Database.fetchDiagnosisForUniqueCode(uq)
        }
      }.map(n =>
          n.map(y=>
            y.map(_.head))) // Future[List[Future[DiagnosisCode]]]
    }
  

CodePudding user response：

If I understood your post correctly, your question is: "How can I convert a Future[List[Future[DiagnosisCode]]] into a Future[List[DiagnosisCode]]?"

The answer to that question would be: use Future.sequence:

// assuming an implicit ExecutionContext is in scope:

val xa: Future[List[Future[DiagnosisCode]]] = // ... your code here
val flattened: Future[List[DiagnosisCode]] =
  xa.flatMap { listOfFutures => 
    Future.sequence(listOfFutures)
  }