Considere el siguiente fragmento de código:
En esto, estoy tratando de obtener valores del futuro utilizando la comprensión 'For - yield'. Ahora en el método de rendimiento, necesito hacer una verificación que hace que la llamada a una función fallbackResult que devuelve un futuro y, por lo tanto, el tipo de retorno de getData se convierte en 'Futuro [Futuro [Opción [Int]]]' en lugar de 'Futuro [Opción [Int ]] '. ¿Cómo podría hacer esto de una mejor manera? (Utilicé Map & FlatMap, pero el código es poco feo debido a la anidación de Maps y FlatMaps)
def getData(): Future[Future[Option[Int]]] = {
/* These are two future vectors. Ignore the Objects */
val substanceTableF: Future[Vector[OverviewPageTableRowModel]] = getSubstanceTable(substanceIds, propertyId, dataRange)
val mixtureTableF: Future[Vector[OverviewPageTableRowModel]] = getMixtureTableForSubstanceCombination(substanceIds, propertyId, dataRange)
/* I have put for yeild to get values from futures.*/
for {
substanceTable <- substanceTableF
mixtureTable <- mixtureTableF
} yield {
if(substanceTable.isEmpty && mixtureTable.isEmpty) {
val resultF = fallbackResult()
resultF.map(result => {Some(result)})
} else {
Future.successful(Some(100))
}
}
}
private def fallbackResult(): Future[Int] = {
// This method returns future of int
}
2 respuestas
Pondría el código dentro de la comprensión:
for {
substanceTable <- substanceTableF
mixtureTable <- mixtureTableF
result <- {
if (substanceTable.isEmpty && mixtureTable.isEmpty)
fallbackResult()
else
Future.successful(Some(100))
}
} yield result
Hay muchas maneras de manejar esto, pero la clave es mover su lógica yield
a su comprensión for
. Una forma de hacerlo es la siguiente:
for {
substanceTable <- substanceTableF
mixtureTable <- mixtureTableF
result <- (substanceTable.headOption orElse mixtureTable.headOption)
.map(_ => Future.successful(Some(100)))
.getOrElse(fallbackResult)
} yield result
Preguntas relacionadas
Nuevas preguntas
scala
Scala es un lenguaje de programación de propósito general dirigido principalmente a la máquina virtual Java. Diseñado para expresar patrones de programación comunes de una manera concisa, elegante y segura de tipos, fusiona estilos de programación imperativos y funcionales. Sus características clave son: un sistema de tipo estático avanzado con inferencia de tipo; tipos de funciones; la coincidencia de patrones; parámetros implícitos y conversiones; sobrecarga del operador; interoperabilidad total con Java; concurrencia