equivalente al operador javascript || en Scala

Question

en JavaScript, podemos hacer algo como:

value = f1() || f2() || f3(); 

Para ello, será f1, y asignarlo a valorar si el resultado no es nulo. solo si el resultado es nulo, llamará a f2 y lo asignará al valor si eso no es nulo. ...

Una forma de lograr esto en Scala se da aquí: How to make this first-not-null-result function more elegant/concise? crear una función getFirstNNWithOption que llama a cada función hasta que no nulo:

value = getFirstNNWithOption(List(f1 _, f2 _, f3 _)) 

Sin embargo, esto no es tan bonito como el Javascript || operador, que es más flexible. por ejemplo:

value = f1() || f2(3) || f3(44, 'ddd') || value4; 

¿hay alguna manera de lograr esto en scala?

Answer 1

Estoy usando el recomendado Option en lugar de null.
Por ejemplo:

class OptionPimp[T](o: Option[T]) { 
    def ||(opt: => Option[T]) = o orElse opt 
    def ||(t: => T) = o getOrElse t 
} 
implicit def optionPimp[T](o: Option[T]) = new OptionPimp(o) 

def f1(): Option[Int] = None 
def f2(): Option[Int] = None 
def f3(): Option[Int] = Some(3) 

val value1 = f1() || f2() || f3() || 4 // yields 3 
val value2 = f1() || f2()   || 4 // yields 4 

Answer 2

Debido a que su está utilizando la función de regresar Option.

La mejor solución sería utilizar la opción de encadenamiento como se explica aquí Option's chaining

Así que haría

f1().orElse(f2()).orElse(f3()).orElse(Some(4)) 

Answer 3

estoy más o menos de la misma opinión que Andy, excepto que había utilizar notación de operadores, y utilizar el método adecuado para defecto:

value = f1 orElse f2(3) orElse f3(44, 'ddd') getOrElse value4 

Answer 4

Si está usando esto con las funciones que pueden devolver nULL, también puede d efine un operador nulo-coalescente:

class NullOption[A <: AnyRef](a: A) { 
    def |?|[B >: A](b: => B) = if (a ne null) a else b 
} 
implicit def null_handling[A <: AnyRef](a: A) = new NullOption(a) 

que funciona igual que Javascript. (He usado |?| para evitar confundirlo con boolean logical o, pero puedes usar || si prefieres). Esto funciona incluso mejor - casi como Option - si agregas un mapa condicional (aquí se llama ? --pick tu palabra favorita o símbolo):

class NullOption[A <: AnyRef](a: A) { 
    def |?|[B >: A](b: => B) = if (a ne null) a else b 
    def ?[C >: Null](f: A => C): C = if (a ne null) f(a) else null 
} 
implicit def null_handling[A <: AnyRef](a: A) = new NullOption(a) 

a continuación, puede

scala> val s: String = null 
s: String = null 

scala> val t: String = "foo" 
t: String = foo 

scala> s?(_.toUpperCase) |?| t |?| { println("I am not executed"); "bar" } 
res4: java.lang.String = "foo" 

Por supuesto, el sistema de tipo no va a ayudarle a recordar que usted necesita para manejar no-es-no-datos de los casos, pero puede hacer que la manipulación nula sea ligeramente más placentera (al menos mientras no haya primitivos, con primitivas, retornando n ull-or-primitive realmente no tiene sentido).

Answer 5

Con la nueva scala 2.10, puede utilizar clases implícitas para actualizar la respuesta de @PeterSchmitz, por lo que no necesita definir una función de conversión implícita.

implicit class OptionPimp[T](o: Option[T]) { 
    def ||(opt: => Option[T]) = o orElse opt 
    def ||(t: => T) = o getOrElse t 
} 

Lo mismo para la respuesta Rex Kerr:

implicit class NullOption[A <: AnyRef](a: A) { 
    def |?|[B >: A](b: => B) = if (a ne null) a else b 
    def ?[C >: Null](f: A => C): C = if (a ne null) f(a) else null 
}