for..else 对于 Scala 中的选项类型？

Question

假设我有两个选项，如果都是 Some，则执行一个代码路径，如果有注释，则执行另一个。我想做一些类似于

for (x <- xMaybe; y <- yMaybe) {
  // do something
}
else {
  // either x or y were None, handle this
}

if 语句之外或模式匹配的事情（如果我有两个以上的选项，则可能无法扩展），是否有更好的方法来处理这个问题？

Answer 1

通过使用 yield 将 for 输出包装在选项中，与您的语法建议非常接近：

val result = { 
  for (x <- xMaybe; y <- yMaybe) yield {
    // do something
  }
} getOrElse {
  // either x or y were None, handle this
}

仅当一个或两个选项时才执行 getOrElse 块没有。

Answer 2

您可以同时对两个 Options 进行模式匹配：

(xMaybe, yMaybe) match {
  case (Some(x), Some(y)) => "x and y are there"
  case _ => "x and/or y were None"
}

Answer 3

Scalaz 中的 traverse 函数概括了您的问题。它需要两个参数：

1. T[F[A]]
2. A => F[B]

并返回 F[T[B]]。 T 是任何可遍历的数据结构，例如 List，F 是任何应用函子，例如 Option。因此，为了专业化，您想要的函数具有以下类型：

• List[Option[A]] => (A => 选项[B]) => Option[List[B]]

因此，将所有 Option 值放入 List

• val z = List(xMaybe, yMaybe)

构造您想要收集结果的函数 got：

• val f: X => Option[Y] = ...

and call traverse

• val r = z traverse f

这种编程模式经常出现。它有一篇论文对此进行了全面讨论，迭代器的本质模式。

注意：我只是想修复 URL，但 CLEVER 编辑帮助告诉我需要更改至少 6 个字符，因此我也包含此有用的链接（scala 示例）：
http://etorreborre.blogspot.com/2011/06/essence -of-iterator-pattern.html

Answer 4

为什么这样的事情不起作用？

val opts = List[Option[Int]](Some(1), None, Some(2))
if (opts contains None) {
  // Has a None
} else {
  // Launch the missiles
  val values = opts.map(_.get) // We know that there is no None in the list so get will not throw
}

Answer 5

如果您不知道正在处理的值的数量，那么托尼的答案是最好的。如果您确实知道要处理的值的数量，那么我建议使用应用函子。

((xMaybe |@| yMaybe) { (x, y) => /* do something */ }).getOrElse(/* something else */)

Answer 6

您说您希望解决方案可扩展：

val optional = List(Some(4), Some(3), None)

if(optional forall {_.isDefined}) {
    //All defined
} else {
    //At least one not defined
}

编辑：刚刚看到Emil Ivanov的解决方案更加优雅。

Answer 7

从 Scala 2.13 开始，我们可以选择使用 Option#zip 连接两个选项如果定义了两个选项，则为它们值的某个元组，否则为 None：

opt1 zip opt2 match {
  case Some((x, y)) => "x and y are there"
  case None         => "x and/or y were None"
}

或使用 Option#fold：

(opt1 zip opt2).fold("x and/or y were None"){ case (x, y) => "x and y are there" }

Answer 8

要扩展到许多选项，请尝试以下操作：

 def runIfAllSome[A](func:(A)=>Unit, opts:Option[A]*) = {
   if(opts.find((o)=>o==None) == None) for(opt<-opts) func(opt.get)
 }

通过此，您可以执行以下操作：

scala> def fun(i:Int) = println(i)
fun: (i: Int)Unit

scala> runIfAllSome(fun, Some(1), Some(2))
1
2

scala> runIfAllSome(fun, None, Some(1))

scala>

Answer 9

我认为这里的关键点是根据您想要做的事情来思考类型。据我了解，您想要迭代选项对列表，然后根据特定条件执行某些操作。

因此，您的问题中有趣的一点是，除了什么之外，返回类型会是什么样子？我认为它看起来像这样：Either[List[Option], List [Option,Option]]。

在错误侧（左侧），您将累积与 None 配对的选项（并且可以说是单独留下的）。在右侧，您可以总结代表您成功价值观的非空选项。所以我们只需要一个能做到这一点的函数。验证每一对并根据其结果（成功 - 失败）进行累加。

实现我所描述内容的一些链接：

• 应用编程、不相交并、半群和不间断错误处理
• 使用 Applicatives 和 Semigroups 进行自动验证（适用于 Sanjiv）< /a>