Wie kombiniere ich Optionswerte in Scala?

Question

Ich möchte eine Operation f: (T,T) => T zu Option[T] Werte in Scala anwenden können. Ich möchte, dass das Ergebnis None ist, wenn einer der beiden Werte None ist.

Genauer gesagt, möchte ich, wenn wissen, gibt es einen kürzeren Weg folgendes zu tun:

def opt_apply[T](f: (T,T) => V, x: Option[T], y: Option[T]): Option[T] = { 
    (x,y) match { 
    case (Some(u),Some(v)) => Some(f(u,v)) 
    case _ => None 
    } 
} 

ich (x zip y) map {case (u,v) => f(u,v)} haben tryied aber das Ergebnis ist ein Iterator[T] kein Option[T].

Jede Hilfe wird geschätzt. Vielen Dank.

Answer 1

scala> val (x, y) = (Some(4), Some(9)) 
x: Some[Int] = Some(4) 
y: Some[Int] = Some(9) 

scala> def f(x: Int, y: Int) = Math.max(x, y) 
f: (x: Int,y: Int)Int 

scala> for { x0 <- x; y0 <- y } yield f(x0, y0) 
res26: Option[Int] = Some(9) 

scala> val x = None 
x: None.type = None 

scala> for { x0 <- x; y0 <- y } yield f(x0, y0) 
res27: Option[Int] = None 

Answer 2

@RahulG ‚s Antwort nutzt die Tatsache aus, dass Option ist eine Monade (obwohl es keine Art ist dies in der Scala Bibliothek darzustellen). Der Compiler erweitert das for Verständnis auf die folgenden:

def a: Option[Int] 
def b: Option[Int] 
val calc: Option[Int] = a flatMap {aa => b map {bb => aa + bb}} 

Sie können es auch als applicative Funktors behandeln, mit etwas Hilfe von Scalaz:

import scalaz._ 
import Scalaz._ 

def a: Option[Int] 
def b: Option[Int] 
val calc: Option[Int] = (a ⊛ b) {_ + _} 

Ein wesentlicher Unterschied besteht darin, dass in der monadischen Berechnung, Ein Fehler (None) der Berechnung a schließt die Auswertung kurz. Im anwendungsspezifischen Stil werden sowohl a als auch b ausgewertet, und wenn beide Some s sind, wird die reine Funktion aufgerufen. Sie können auch sehen, dass in der monadischen Berechnung der Wert aa in der Berechnung b hätte verwendet werden können; in der applikativen Version kann b nicht von dem Ergebnis a abhängen.

Answer 3

Ich habe eine etwas ältere Version von scalaz als retronym aber die folgenden Werke für mich als Beispiel und ist verallgemeinerbar für den Fall, dass Sie drei Typen haben T, U, V und nicht nur ein:

def main(args: Array[String]) { 
    import scalaz._ 
    import Scalaz._ 

    val opt1 = some(4.0) //Option[Double] 
    val opt2 = some(3) //Option[Int] 

    val f: (Double, Int) => String = (d, i) => "[%d and %.2f]".format(i, d) 

    val res = (opt1 <|*|> opt2).map(f.tupled) 
    println(res) //Some([3 and 4.00]) 
} 

dann kann ich hinzufügen:

val opt3 = none[Int] 
val res2 = (opt1 <|*|> opt3).map(f.tupled) 
println(res2) //None 

Answer 4

können Sie für Comprehensions verwenden:

def opt_apply[T](f: (T,T) => T, x: Option[T], y: Option[T]): Option[T] = 
    for (xp <- x; yp <- y) yield (f(xp,yp)) 

der Zucker ist für:

x flatMap {xp => y map {yp => f(xp, yp)}} 

Dies auch aufgrund der Option möglich ist, einen Monad sind

Answer 5

def optApply[A,B,C](f: (A, B) => C, a: Option[A], b: Option[B]): Option[C] = 
    a.zip(b).headOption.map { tup => f.tupled(tup) } 

a.zip(b) in einem Iterable führt [(A, B)] (mit, weil es von Optionen ist, höchstens ein Element). headOption gibt dann das erste Element als Option zurück.