ternario Operador similar a:?

Question

que estoy tratando de evitar las construcciones de esta manera:

val result = this.getClass.getSimpleName 
if (result.endsWith("$")) result.init else result 

Ok, en este ejemplo el then y else rama son simples, pero se puede los complejos de imagen. que construyeron los siguientes:

object TernaryOp { 
    class Ternary[T](t: T) { 
    def is[R](bte: BranchThenElse[T,R]) = if (bte.branch(t)) bte.then(t) else bte.elze(t) 
    } 
    class Branch[T](branch: T => Boolean) { 
    def ?[R] (then: T => R) = new BranchThen(branch,then) 
    } 
    class BranchThen[T,R](val branch: T => Boolean, val then: T => R) 
    class Elze[T,R](elze: T => R) { 
    def :: (bt: BranchThen[T,R]) = new BranchThenElse(bt.branch,bt.then,elze) 
    } 
    class BranchThenElse[T,R](val branch: T => Boolean, val then: T => R, val elze: T => R) 
    implicit def any2Ternary[T](t: T) = new Ternary(t) 
    implicit def fct2Branch[T](branch: T => Boolean) = new Branch(branch) 
    implicit def fct2Elze[T,R](elze: T => R) = new Elze(elze) 
} 

definido que, puedo reemplazar el sencillo ejemplo anterior con:

this.getClass.getSimpleName is {s: String => s.endsWith("$")} ? {s: String => s.init} :: {s: String => s} 

Pero, ¿cómo puedo deshacerme de la s: String =>? Quiero algo así:

this.getClass.getSimpleName is {_.endsWith("$")} ? {_.init} :: {identity} 

Supongo que el compilador necesita el material extra para inferir los tipos.

Answer 1

podemos combinar How to define a ternary operator in Scala which preserves leading tokens? con la respuesta a Is Option wrapping a value a good pattern? para obtener

scala> "Hi".getClass.getSimpleName |> {x => x.endsWith("$") ? x.init | x} 
res0: String = String 

scala> List.getClass.getSimpleName |> {x => x.endsWith("$") ? x.init | x} 
res1: String = List 

Es esto adecuado para sus necesidades?

Answer 2

Rex Kerr’s answer expresa en Scala básica:

"Hi".getClass.getSimpleName match { 
    case x if x.endsWith("$") => x.init 
    case x => x 
} 

aunque no estoy seguro de qué parte de la si-else que desea optimizar.

Answer 3

De Tony Morris' Lambda Blog:

escucho esta pregunta mucho. Sí lo hace. En lugar de c ? p : q, está escrito if(c) p else q.

Esto puede no ser preferible. Tal vez le gustaría escribir usando la misma sintaxis que Java. Tristemente, no puedes. Esto es porque : no es un identificador válido. No temas, | es! ¿Te conformarías con esto?

c ? p | q 

Luego necesitará el siguiente código. Observe las anotaciones de llamada por nombre (=>) en los argumentos. Esta estrategia de evaluación es necesaria para reescribir correctamente el operador ternario de Java. Esto no se puede hacer en Java.

case class Bool(b: Boolean) { 
    def ?[X](t: => X) = new { 
    def |(f: => X) = if(b) t else f 
    } 
} 

object Bool { 
    implicit def BooleanBool(b: Boolean) = Bool(b) 
} 

Aquí hay un ejemplo usando el nuevo operador que acabamos de definir:

object T { val condition = true 

    import Bool._ 

    // yay! 
    val x = condition ? "yes" | "no" 
} 

Diviértete;)

Answer 4

desde: por sí sola no será un operador válida a menos que esté bien con siempre escapándolo con retrocesos :, podría ir con otro personaje, por ejemplo "|" como en una de las respuestas anteriores. Pero ¿qué hay de Elvis con una perilla? ::

implicit class Question[T](predicate: => Boolean) { 
    def ?(left: => T) = predicate -> left 
} 
implicit class Colon[R](right: => R) { 
    def ::[L <% R](pair: (Boolean, L)): R = if (q._1) q._2 else right 
} 
val x = (5 % 2 == 0) ? 5 :: 4.5 

Por supuesto esto de nuevo no funcionará si los valores son listas, ya que tienen :: operador de sí mismos.

Answer 5

Desde if-else construcciones en Scala devuelven un valor, puede utilizar esta

val a = if (1 < 0) 1 else 2 

Más información: https://alvinalexander.com/scala/scala-if-then-ternary-operator-cookbook-examples