Come combinare i valori delle opzioni in Scala?

Question

Desidero poter applicare un'operazione con valori f: (T,T) => T a Option[T] in Scala. Voglio che il risultato sia None se uno qualsiasi dei due valori è None.

Più in particolare, voglio sapere se c'è un modo più breve per effettuare le seguenti operazioni:

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 
    } 
} 

ho tryied (x zip y) map {case (u,v) => f(u,v)} ma il risultato è un non Iterator[T] un Option[T].

Qualsiasi aiuto sarà apprezzato. Grazie.

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

risposta @RahulG s' sfrutta il fatto che Option è una monade (anche se non v'è alcun tipo di rappresentare questo nella libreria Scala). Il compilatore espande la for comprensione al seguente:

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

È inoltre possibile trattarlo come un funtore applicativa, con qualche aiuto da Scalaz:

import scalaz._ 
import Scalaz._ 

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

Una differenza chiave è che nel calcolo della monade, un errore (ovvero None) del calcolo a cortocircuiti della valutazione. Nello stile applicativo, vengono valutati sia a sia b e se entrambi sono Some s, viene chiamata la funzione pura. È inoltre possibile vedere che nel calcolo monadico, il valore aa avrebbe potuto essere utilizzato nel calcolo b; nella versione applicativa, b non può dipendere dal risultato di a.

Answer 3

Ho una versione leggermente più vecchio di scalaz di retronym ma i seguenti lavori per me come un esempio ed è generalizzabile per il caso in cui si dispone di 3 tipi T, U, V e non uno solo:

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]) 
} 

posso quindi aggiungere:

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

Answer 4

È possibile utilizzare espressioni for:

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)) 

Quale è lo zucchero per:

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

Ciò è possibile anche grazie alla opzione di essere un Monade

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) non risultare in un Iterable [(A, B)] (con, perché proviene da Opzioni, al massimo un elemento). headOption quindi restituisce il primo elemento come un'opzione.