使用未来的回应

Question

希望有人能就这个问题的解决方案提出意见。

我将尽量简化问题，以节省带来的领域问题，等等。

我有一个可选字符串的列表。我使用收集方法基本上过滤掉不存在的字符串。

names collect {
    case Some(value) => value
}

很简单。我还想再往前走一步。如果一个值是None，我想调用一个函数并使用它的响应来代替None。例如

names collect {
    case Some(value) => value
    case _ => getData(_)
}

捕获是getData方法返回一个未来。我理解未来的约定建议在回调中访问值，因此类似于map方法或完全，但问题是，在我进入getData方法并拥有该值之前，我不知道是否需要调用该方法，所以我不能简单地将所有的逻辑封装在getData上的map方法中。这不像使用等待和阻塞是一个好主意。

如果你知道我如何合理地处理这件事，我将不胜感激。对于Scala来说非常新，所以我很想听听大家的意见和选择。

编辑：

我试图简化这个问题，但我认为我忽略了关键信息。

以下是我的方法的实际实现：

def calculateTracksToExport()(
  implicit exportRequest: ExportRequest,
  lastExportOption: Option[String]
): Future[List[String]] = {
    val vendorIds = getAllFavouritedTracks().flatMap { favTracks =>
        Future.sequence {
            favTracks.map { track =>
                musicClient.getMusicTrackDetailsExternalLinks(
                  track,
                  exportRequest.vendor.toString.toLowerCase
                ).map { details =>
                    details.data.flatMap { data =>
                        data.`external-links`.map { link =>
                            link.map(_.value).collect {
                                case Some(value) => value
                                case None => getData(track)
                            }
                        }
                    }.getOrElse(List())
                }
            }
        }.map(_.flatten)
    }
    vendorIds
}

Answer 1

您可以使用Future.sequence来收集值：

def collect(list:List[Option[String]]):Future[List[String]] = Future.sequence(
  list.map {
    case Some(item) => Future.successful(item)
    case _ => getData()
  }
)

Answer 2

如果将来有什么事情，你必须把它当作未来来对待。因此，以期货序列作为回报价值：

def resolve[T](input: Seq[Option[T]], supplier: => Future[T]): Seq[Future[T]] = {
    input.map(option => option.map(Future.successful).getOrElse(supplier))
}

用法示例：

// Input to process
val data = Seq(Some(1), None, Some(2), None, Some(5))

//Imitates long-running background process producing data
var count = 6
def getData: Future[Int] = Future( {
    Thread sleep (1000)
    count += 1
    count
})


resolve(data, getData) // Resolve Nones
  .map(Await.result(_, 10.second)).foreach( println ) // Use result        

产出：

1
8
2
7
5

http://ideone.com/aa8nJ9