13

基本的に、私は次のことを行うための最もスカラのような方法を探しています：

def sum(value1: Option[Int], value2: Option[Int]): Option[Int] = 
  if(value1.isDefined && value2.isDefined) Some(value1.get + value2.get)
  else if(value1.isDefined && value2.isEmpty) value1
  else if(value1.isEmpty && value2.isDefined) value2
  else None

これにより、正しい出力が得られます。

sum(Some(5), Some(3))  // result = Some(8)
sum(Some(5), None)     // result = Some(5)
sum(None, Some(3))     // result = Some(3)
sum(None, None)        // result = None

しかし、3つ以上のオプションを合計するには、あまりにも多くifのsを使用するか、ある種のループを使用する必要があります。

編集-1：

質問を書いている間、私はある種の答えを思いついた：

def sum2(value1: Option[Int], value2: Option[Int]): Option[Int] = 
  value1.toList ::: value2.toList reduceLeftOption { _ + _ }

これは私の経験の浅い目には非常に慣用的に見えます。これは、3つ以上の値でも機能します。それでも、リストに変換せずに同じことを行うことは可能ですか？

編集-2：

私はこの解決策に行き着きました（ziggystarのおかげで）：

def sum(values: Option[Int]*): Option[Int] = 
  values.flatten reduceLeftOption { _ + _ }

編集-3：

Landeiのおかげで別の選択肢：

def sum(values: Option[Int]*): Option[Int] = 
  values collect { case Some(n) => n } reduceLeftOption { _ + _ }
4

5 に答える 5

10

どうですか：

scala> def sum(values: Option[Int]*): Option[Int] = values.flatten match {
     | case Nil => None                                                   
     | case l => Some(l.sum)                                              
     | }
sum: (values: Option[Int]*)Option[Int]

scala> sum(Some(1), None)
res0: Option[Int] = Some(1)

scala> sum(Some(1), Some(4))
res1: Option[Int] = Some(5)

scala> sum(Some(1), Some(4), Some(-5))
res3: Option[Int] = Some(0)

scala> sum(None, None)                
res4: Option[Int] = None

編集

すべての引数がNoneの場合、0を返すのは正気かもしれません。その場合、関数はに減少しvalues.flatten.sumます。

于 2011-04-29T13:46:33.743 に答える
7 
scala> def sum(a: Option[Int], b: Option[Int]) = (a,b) match {
     |   case (Some(x), Some(y)) => Some(x + y)
     |   case (Some(x), None) => Some(x)
     |   case (None, Some(y)) => Some(y)
     |   case _ => None
     | }
sum: (a: Option[Int],b: Option[Int])Option[Int]

scala> sum(Some(5), Some(3))
res0: Option[Int] = Some(8)

scala> sum(Some(5), None)
res1: Option[Int] = Some(5)

scala> sum(None, Some(3))
res2: Option[Int] = Some(3)

scala> sum(None, None)
res3: Option[Int] = None
于 2011-04-29T14:03:23.773 に答える
5

別の解決策は次のとおりです。

def sum(values: Option[Int]*): Int = values.collect{case Some(n) => n}.sum

現在の場合flattenは明らかにより便利ですが、collectバージョンはより柔軟であり、マッピングを実行し、追加のフィルター条件または複雑なパターンを持つことができます。たとえば、すべての偶数の2乗の合計を値にしたいとします。

values.collect{case Some(n) if n mod 2 == 0 => n*n}.sum
于 2011-04-29T21:12:33.350 に答える
5

あなたはそれがあなたが望むことを正確にSemigroup行うためのインスタンスがあるという事実を使ってそれを非常に簡潔にすることができます。scalazまたはcatsOptionを使用できます。以下を使用した例を次に示します。cats

import cats.std.option._
import cats.syntax.semigroup._
import cats.std.int._

Option(1) |+| Option(2) // Some(3)
Option(1) |+| None      // Some(1)
None      |+| Option(2) // Some(2)

だからあなたsumはなります：

def sum(v1: Option[Int], v2: Option[Int]): Option[Int] = v1 |+| v2
于 2016-04-17T18:25:32.013 に答える
4

いくつかの基本的な数学的規則に少し目を向けたmichael.kebeの縮小解：

def sum(a: Option[Int], b: Option[Int]) = (a,b) match {
  case (None,None) => None
  case _ => Some(a.getOrElse(0)+b.getOrElse(0))
}

scala> sum(Some(5), Some(3))  // result = Some(8)
res6: Option[Int] = Some(8)

scala> sum(Some(5), None)     // result = Some(5)
res7: Option[Int] = Some(5)

scala> sum(None, Some(3))     // result = Some(3)
res8: Option[Int] = Some(3)

scala> sum(None, None)        // result = None
res9: Option[Int] = None
于 2011-04-30T10:20:09.360 に答える