Ternärer Operator ähnlich?

Ich versuche solche Konstrukte zu vermeiden:

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

Ok, in diesem Beispiel sind der thenund else-Zweig einfach, aber Sie können sich komplexe vorstellen. Ich habe folgendes gebaut:

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

Definiert, kann ich das obige einfache Beispiel ersetzen durch:

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

Aber wie kann ich das loswerden s: String =>? Ich möchte so etwas:

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

Ich denke, der Compiler benötigt das zusätzliche Material, um Typen abzuleiten.

Wir können kombinieren Wie man einen ternären Operator in Scala definiert, der führende Token bewahrt? mit der Antwort auf Ist Option, die einen Wert umschließt, ein gutes Muster? bekommen

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

Ist das für Ihre Bedürfnisse angemessen?

Aus Tony Morris 'Lambda-Blog :

Ich höre diese Frage oft. Ja tut es. Stattdessen c ? p : qwird geschrieben if(c) p else q.

Dies ist möglicherweise nicht vorzuziehen. Vielleicht möchten Sie es mit der gleichen Syntax wie Java schreiben. Das kannst du leider nicht. Dies liegt daran, dass :es sich nicht um eine gültige Kennung handelt. Fürchte dich nicht, |ist! Würden Sie sich damit zufrieden geben?

c ? p | q

Dann benötigen Sie den folgenden Code. Beachten Sie die =>Annotationen call-by-name ( ) zu den Argumenten. Diese Auswertungsstrategie ist erforderlich, um den ternären Operator von Java korrekt neu zu schreiben. Dies ist in Java selbst nicht möglich.

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

Hier ist ein Beispiel mit dem neuen Operator, den wir gerade definiert haben:

object T {   val condition = true

  import Bool._

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

Habe Spaß ;)

Rex Kerrs Antwort in Scala ausgedrückt:

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

obwohl ich nicht sicher bin, welchen Teil des if-else-Konstrukts Sie optimieren möchten.

Da if-else-Konstruktionen in Scala einen Wert zurückgeben, können Sie diesen verwenden

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

Weitere Informationen: https://alvinalexander.com/scala/scala-if-then-ternary-operator-cookbook-examples

Da: an sich kein gültiger Operator ist, es sei denn, Sie können ihn immer mit Back Ticks umgehen :, können Sie ein anderes Zeichen verwenden, z. B. "|" wie in einer der obigen Antworten. Aber wie wäre es mit Elvis mit einem Spitzbart? ::

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

Dies funktioniert natürlich wieder nicht, wenn Ihre Werte Listen sind, da sie selbst den Operator :: haben.