Simplifique si (x) Algo (y) else ¿Ninguna?

Question

Este patrón común se siente un poco prolijo:

if (condition) 
    Some(result) 
else None 

Yo estaba pensando en usar una función para simplificar:

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

Esto reduce el ejemplo de arriba a:

on (condition) { result } 

hace algo como esto ya existe? ¿O es esto exagerado?

Answer 1

Scalaz incluye la función option:

import scalaz.syntax.std.boolean._ 

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

Answer 2

Se puede crear la primera Option y filtrar en que con su condición:

Option(result).filter(condition) 

o si condition no está relacionado con result

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

Answer 3

Usted puede utilizar el objeto PartialFunction compañero y 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

Aquí hay otro enfoque que es bastante sencillo:

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

Un ejemplo sencillo:

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 

Aquí algunos ejemplos no booleanas avanzados que ponen a la condición en la coincidencia de patrón:

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)