Semplifica se (x) Alcuni (y) altro Nessuno?

Question

Questo modello comune si sente un po 'prolisso:

if (condition) 
    Some(result) 
else None 

Stavo pensando di utilizzare una funzione per semplificare:

def on[A](cond: Boolean)(f: => A) = if (cond) Some(f) else None 

Questo riduce l'esempio in alto a:

on (condition) { result } 

fa qualcosa come questo esiste già? O è questo eccessivo?

Answer 1

Scalaz include la funzione option:

import scalaz.syntax.std.boolean._ 

true.option("foo") // Some("foo") 
false.option("bar") // None 

Answer 2

Si potrebbe creare il primo Option e filtrare su quella con la vostra condizione:

Option(result).filter(condition) 

o se condition non è legato alla result

Option(result).filter(_ => condition) 

Answer 3

È possibile utilizzare l'oggetto PartialFunction compagno e condOpt:

PartialFunction.condOpt(condition) {case true => result} 

Uso:

scala> PartialFunction.condOpt(false) {case true => 42} 
res0: Option[Int] = None 

scala> PartialFunction.condOpt(true) {case true => 42} 
res1: Option[Int] = Some(42) 

Answer 4

import scalaz._, Scalaz._ 
val r = (1 == 2) ? Some(f) | None 
System.out.println("Res = " + r) 

Answer 5

Ecco un altro approccio che è molto semplice:

Option(condition).collect{ case true => result } 

Un semplice esempio:

scala> val enable = true 
enable: Boolean = true 

scala> Option(enable).collect{case true => "Yeah"} 
res0: Option[String] = Some(Yeah) 

scala> Option(!enable).collect{case true => "Yeah"} 
res1: Option[String] = None 

Ecco alcuni esempi non booleane avanzate che mettono la condizione che la partita modello:

val param = "beta" 
Option(param).collect{case "alpha" => "first"} // gives None 

Option(param).collect{case "alpha" => "first" 
         case "beta" => "second" 
         case "gamma" => "third"} // gives Some(second) 

val number = 999 
Option(number).collect{case 0 => "zero" 
         case x if x > 10 => "too high"} // gives Some(too high)