我有一个列表l:List[T1]，目前我正在做以下事情：
myfun : T1 -> Option[T2]
val x: Option[T2] = l.map{ myfun(l) }.flatten.find(_=>true)
myfun 函数返回 None 或 Some，flatten 丢弃所有 None 并 find 返回列表的第一个元素（如果有）。
这对我来说似乎有点 hacky。我认为可能存在一些便于理解或类似的东西，这会减少浪费或更聪明。
例如：如果myfun 在列表l 的map 期间返回any Some，我不需要任何后续答案。
【问题讨论】：
标签： list scala functional-programming scala-option
怎么样：
l.toStream flatMap (myfun andThen (_.toList)) headOption
Stream 是惰性的，因此它不会提前映射所有内容，但也不会重新映射所有内容。将 Option 转换为 List 以便使用 flatMap，而不是扁平化。
【讨论】：
fun 是 def，而不是函数 T => Option[T]。
除了使用toStream使搜索变得懒惰，我们还可以使用Stream::collectFirst：
List(1, 2, 3, 4, 5, 6, 7, 8).toStream.map(myfun).collectFirst { case Some(d) => d }
// Option[String] = Some(hello)
// given def function(i: Int): Option[String] = if (i == 5) Some("hello") else None
这个：
将List 转换为Stream 以便提前停止搜索。
使用myFun 将元素转换为Option[T]s。
收集不是None的第一个映射元素并提取它。
从 Scala 2.13 开始，弃用 Streams 以支持 LazyLists，这将变为：
List(1, 2, 3, 4, 5, 6, 7, 8).to(LazyList).map(function).collectFirst { case Some(d) => d }
【讨论】：
Stream - List 也有一个collectFirst 方法，您可以使用Function.unlift 将函数本身转换为PartialFunction。跨度>
collectFirst 匹配列表中的第一个元素，那么如果没有惰性序列（流/迭代器/惰性列表），您将浪费地在所有元素上应用function 映射即使您真的只需要为第一个元素应用它，该列表也是如此。此外，通过在collectFirst 的提升部分中应用function 操作，您还必须在collectFirst 的映射部分中再次应用它，如果function 很昂贵，这可能会很浪费。
嗯，这差不多，但不完全
val x = (l flatMap myfun).headOption
但是您从 myfun 返回 Option 而不是 List，所以这可能行不通。如果是这样（我手头没有 REPL），那就试试吧：
val x = (l flatMap(myfun(_).toList)).headOption
【讨论】：
嗯，理解等价物很容易
(for(x<-l, y<-myfun(x)) yield y).headOption
如果您真的进行翻译，结果与 oxbow_lakes 给出的相同。假设 List.flatmap 有合理的惰性，这是一个既干净又高效的解决方案。
【讨论】：
l 替换为 l.view 会导致 myfun 使用相同的参数被多次评估。
截至 2017 年，之前的答案似乎已经过时。我运行了一些基准测试（1000 万个 Ints 列表，第一个匹配大致在中间，Scala 2.12.3、Java 1.8.0、1.8 GHz Intel Core i5）。除非另有说明，list 和 map 具有以下类型：
list: scala.collection.immutable.List
map: A => Option[B]
只需调用列表中的map：~1000 毫秒
list.map(map).find(_.isDefined).flatten
第一次调用列表中的toStream：~1200 ms
list.toStream.map(map).find(_.isDefined).flatten
在列表中调用toStream.flatMap：~450 ms
list.toStream.flatMap(map(_).toList).headOption
在列表中调用flatMap：~100 毫秒
list.flatMap(map(_).toList).headOption
第一次调用列表中的iterator：~35 ms
list.iterator.map(map).find(_.isDefined).flatten
递归函数find()：~25 ms
def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = {
list match {
case Nil => None
case head::tail => map(head) match {
case None => find(tail, map)
case result @ Some(_) => result
}
}
}
迭代函数find()：~25 ms
def find[A,B](list: scala.collection.immutable.List[A], map: A => Option[B]) : Option[B] = {
for (elem <- list) {
val result = map(elem)
if (result.isDefined) return result
}
return None
}
您可以通过使用 Java 而不是 Scala 集合和功能较少的样式来进一步加快速度。
在java.util.ArrayList 中循环索引：~15 ms
def find[A,B](list: java.util.ArrayList[A], map: A => Option[B]) : Option[B] = {
var i = 0
while (i < list.size()) {
val result = map(list.get(i))
if (result.isDefined) return result
i += 1
}
return None
}
循环java.util.ArrayList 中的索引，函数返回null 而不是None：~10 毫秒
def find[A,B](list: java.util.ArrayList[A], map: A => B) : Option[B] = {
var i = 0
while (i < list.size()) {
val result = map(list.get(i))
if (result != null) return Some(result)
i += 1
}
return None
}
（当然，通常将参数类型声明为java.util.List，而不是java.util.ArrayList。我在这里选择后者是因为它是我用于基准测试的类。java.util.List 的其他实现将显示不同的性能 -大多数情况会更糟。）
【讨论】：