Operatore ternario simile a?:

Sto cercando di evitare costrutti come questo:

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

Ok, in questo esempio i rami thene elsesono semplici, ma puoi immaginare quelli complessi. Ho costruito quanto segue:

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

Definito questo, posso sostituire il semplice esempio sopra con:

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

Ma come posso sbarazzarmene s: String =>? Voglio qualcosa del genere:

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

Immagino che il compilatore abbia bisogno di cose extra per dedurre i tipi.

Possiamo combinare Come definire un operatore ternario in Scala che preserva i token iniziali? con la risposta a Opzione che avvolge un valore è un buon modello? ottenere

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

È adeguato alle tue esigenze?

Dal blog Lambda di Tony Morris :

Ho sentito spesso questa domanda. Sì lo fa. Invece di c ? p : q, è scritto if(c) p else q.

Questo potrebbe non essere preferibile. Forse ti piacerebbe scriverlo usando la stessa sintassi di Java. Purtroppo, non puoi. Questo perché :non è un identificatore valido. Non temere, lo |è! Ti accontenteresti di questo?

c ? p | q

Allora avrai bisogno del seguente codice. Notare le =>annotazioni call-by-name ( ) sugli argomenti. Questa strategia di valutazione è necessaria per riscrivere correttamente l'operatore ternario di Java. Questo non può essere fatto in Java stesso.

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

Ecco un esempio che utilizza l'operatore new che abbiamo appena definito:

object T {   val condition = true

  import Bool._

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

Divertiti ;)

La risposta di Rex Kerr espressa in Scala di base:

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

anche se non sono sicuro di quale parte del costrutto if – else desideri ottimizzare.

Poiché le costruzioni if-else in Scala restituiscono un valore, puoi usarlo

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

Maggiori informazioni: https://alvinalexander.com/scala/scala-if-then-ternary-operator-cookbook-examples

Poiché: di per sé non sarà un operatore valido a meno che tu non sia d'accordo con l'escape sempre :con i segni di spunta indietro , potresti usare un altro carattere, ad esempio "|" come in una delle risposte sopra. Ma che ne dici di elvis con il pizzetto? ::

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

Ovviamente anche questo non funzionerà se i valori sono elenchi, poiché hanno l'operatore :: essi stessi.