scala - How do I find the min() or max() of two Option[Int]

Question

How would you find minValue below? I have my own solution but want to see how others would do it.

val i1: Option[Int] = ...
val i2: Option[Int] = ...
val defaultValue: Int = ...
val minValue = ?

Answer 1

更新：我刚刚注意到我下面的解决方案和您答案中的解决方案的行为不同 - 我将您的问题读作当有两个值时要求两个值中的最小值，但在您的回答中，您实际上是在将None其视为包含一个大于 (for min) 或小于 (for max) 的值。

更具体地说：如果i1isSome(1)和i2is None，我的解决方案将返回默认值，而您的解决方案将返回 1。

如果您想要后一种行为，您可以使用默认的半群实例 forOption[A]和热带半群for Int。例如，在 Scalaz 7 中，您可以编写：

import scalaz._, Scalaz._

optionMonoid(Semigroup.minSemigroup[Int]).append(i1, i2) getOrElse defaultValue

或以下简写：

Tags.Min(i1) |+| Tags.Min(i2) getOrElse defaultValue

它不像下面的应用函子解决方案那么干净，但如果这是你的问题，那就是你的问题。

---

这是一种不涉及创建额外列表的更惯用的方式：

(for { x <- i1; y <- i2 } yield math.min(x, y)) getOrElse defaultValue

或者，等效地：

i1.flatMap(x => i2.map(math.min(x, _))) getOrElse defaultValue

您正在做的是将两位函数 ( min) “提升”为应用函子 ( Option)。Scalaz使用其适用的构建器语法使这变得简单：

import scalaz._, Scalaz._

(i1 |@| i2)(math.min) getOrElse defaultValue

在这种情况下，标准库解决方案并没有那么优雅，但这是一个有用的抽象。

Answer 2

我使用以下方法解决了类似的问题。当两个选项都有值时，我们处理一种特殊情况，否则我们使用 API 方法Option.orElse。

val a: Option[Int]  = Some(10)
val b: Option[Int] = Some(20)
val c: Option[Int] = (a, b) match {
  case (Some(x), Some(y)) => Some(x min y)
  case (x, y) => x orElse y
}

Answer 3

我想这就是你所追求的：

val minValue = List(i1, i2).flatten match {
  case Nil => defaultValue
  case xs => xs.min
}

我会避免sorted，因为排序需要比简单地找到最大值或最小值更多的处理（尽管在这种情况下它可能没有太大区别）。

Answer 4

val minValue: Int = List(i1, i2).flatten.sorted.headOption getOrElse defaultValue

Answer 5

您可以在 for 表达式中使用模式，与模式不匹配的值将被丢弃。

(for (Some(x) <- List(None, Some(3))) yield x) max

虽然不如 List.flatten 方法好。

Answer 6

如果您想避免使用 scalaz 和 map/for/getOrElse，您可以执行以下操作：

val minValue = (i1, i2) match {
  case (Some(x), Some(y)) => math.min(x, y)
  case _ => defaultValue
}

Answer 7

我们可以将 2 Options 组合为Iterablewith运算符，这允许我们使用（很好地处理由 case 形成的空迭代的情况）并在必要时回退到默认值：Option++minOptionNone/NonegetOrElse

(optionA ++ optionB).minOption.getOrElse(-1)
// None and None       => -1
// Some(5) and None    => 5
// None and Some(5)    => 5
// Some(5) and Some(3) => 3

Answer 8

另一个没有提到的选项是使用reduceLeftOption（交换math.max和math.min根据需要）：

val min = (first ++ second).reduceLeftOption(math.min).getOrElse(defaultValue)

---

scala> val first = Some(10)
first: Some[Int] = Some(10)

scala> val second: Option[Int] = None
second: Option[Int] = None

scala> val defaultMin = -1
defaultMin: Int = -1

scala> (first ++ second).reduceLeftOption(math.min).getOrElse(defaultMin)
res7: Int = 10

scala> val first: Option[Int] = None
first: Option[Int] = None

scala> (first ++ second).reduceLeftOption(math.min).getOrElse(defaultMin)
res8: Int = -1

scala> val first = Some(10)
first: Some[Int] = Some(10)

scala> val second = Some(42)
second: Some[Int] = Some(42)

scala> (first ++ second).reduceLeftOption(math.min).getOrElse(defaultMin)
res9: Int = 10

Answer 9

tl;博士

您可以使用自定义猫 Semigroup实例来完成您需要优雅的操作：

import cats.kernel.Semigroup
import cats.instances.option._ // this import is for cats std option combiner
import cats.syntax.semigroup._

object Implicits {
 implicit val intMinSemigroup: Semigroup[Int] =
   (x: Int, y: Int) => math.min(x, y)

 implicit val intMaxSemigroup: Semigroup[Int] =
   (x: Int, y: Int) => math.max(x, y)
}
 
import Implicits.intMinSemigroup
// these are results for minSemigroup
// List((Some(1),Some(1),Some(2)), (Some(1),Some(1),None), (None,Some(2),Some(2)), (None,None,None))
//import Implicits.intMaxSemigroup
// these are results for maxSemigroup
// List((Some(1),Some(2),Some(2)), (Some(1),Some(1),None), (None,Some(2),Some(2)), (None,None,None))
   
for {
 maybeA <- Seq(Some(1), None)
 maybeB <- Seq(Some(2), None)
} yield (maybeA, maybeA |+| maybeB, maybeB)

如果要替换None为默认值，可以使用 combine 两次：

val defaultValue: Int = 3
val optionMin = for {
  maybeA <- Seq(Some(1), None)
  maybeB <- Seq(Some(2), None)
} yield (maybeA |+| maybeB) |+| Some(defaultValue)
// List(Some(1), Some(1), Some(2), Some(3))

这个怎么运作

简而言之，Semigroup[A]是typeclass用于将相同类型的两个值组合A成 type 的一个值A。这里我们使用标准猫OptionMonoid（它扩展Semigroup[Option[A]]）这里的源代码：

class OptionMonoid[A](implicit A: Semigroup[A]) extends Monoid[Option[A]] {
  def empty: Option[A] = None
  def combine(x: Option[A], y: Option[A]): Option[A] =
    x match {
      case None => y
      case Some(a) =>
        y match {
          case None    => x
          case Some(b) => Some(A.combine(a, b))
        }
    }
}

我们看到它需要他自己进行选项匹配，我们应该给他工作的一切都是implicit A: Semigroup[A]. 在我们的案例中，我们为min,max案例编写了两个不同的组合器：

object Implicits {
 implicit val intMinSemigroup: Semigroup[Int] =
   (x: Int, y: Int) => math.min(x, y)

 implicit val intMaxSemigroup: Semigroup[Int] =
   (x: Int, y: Int) => math.max(x, y)
}

因此，我们导入组合器（即import Implicits.intMinSemigroup）并仅cats.syntax.semigroup用于使用组合函数作为运算符|+|：

maybeA |+| maybeB.

总之，您可以为任何类型（不仅）定义自定义半组，并在导入一些猫语法和实例后组合此类型的选项。Int