Üçlü Operatör Benzer?:

Bunun gibi yapılardan kaçınmaya çalışıyorum:

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

Tamam, bu örnekte thenve elsedalı basittir, ancak karmaşık olanları görüntüleyebilirsiniz. Aşağıdakileri oluşturdum:

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

Bunu tanımladığımda, yukarıdaki basit örneği şununla değiştirebilirim:

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

Ama nasıl kurtulabilirim s: String =>? Bunun gibi bir şey istiyorum:

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

Sanırım derleyicinin türleri çıkarmak için fazladan malzemeye ihtiyacı var.

Biz birleştirebilirsiniz lider jetonları koruyan Scala'da bir üçlü operatörü nasıl tanımlanır? cevap ile bir değer iyi bir model sarma Is Seçeneği? almak

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

Bu ihtiyaçlarınız için yeterli mi?

Gönderen Tony Morris'in Lambda Blog :

Bu soruyu çok duyuyorum. Evet öyle. Bunun yerine c ? p : qyazılırif(c) p else q .

Bu tercih edilmeyebilir. Belki Java ile aynı sözdizimini kullanarak yazmak istersiniz. Ne yazık ki yapamazsınız. Bunun nedeni :, geçerli bir tanımlayıcı olmamasıdır. Korkma, |öyle! Buna razı olur musun?

c ? p | q

O zaman aşağıdaki koda ihtiyacınız olacak. =>Bağımsız değişkenler üzerindeki ada göre çağrı ( ) ek açıklamalarına dikkat edin. Bu değerlendirme stratejisi, Java'nın üçlü operatörünü doğru şekilde yeniden yazmak için gereklidir. Bu Java'nın kendisinde yapılamaz.

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

İşte az önce tanımladığımız yeni operatörü kullanan bir örnek:

object T {   val condition = true

  import Bool._

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

İyi eğlenceler ;)

Rex Kerr'in cevabı temel Scala'da ifade edildi:

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

eğer-else yapısının hangi bölümünü optimize etmek istediğinizden emin değilim.

Scala'daki if-else yapıları bir değer döndürdüğünden, bunu kullanabilirsiniz

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

Daha fazla bilgi: https://alvinalexander.com/scala/scala-if-then-ternary-operator-cookbook-examples

Çünkü: her zaman geri tiklerle kaçmadığınız sürece kendi başına geçerli bir operatör olmayacaktır :, başka bir karakterle gidebilirsiniz, örneğin "|" yukarıdaki cevaplardan birinde olduğu gibi. Ama keçi sakallı elvis nasıl olur?

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

Elbette, eğer değerler listesiyse bu yine işe yaramayacaktır, çünkü kendilerinin :: operatörü vardır.