Operator Ternary Mirip Dengan?:

Saya mencoba menghindari konstruksi seperti ini:

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

Oke, dalam contoh ini, cabang thendan elsesederhana, tetapi Anda dapat menggambar yang kompleks. Saya membuat yang berikut ini:

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

Mendefinisikan itu, saya dapat mengganti contoh sederhana di atas dengan:

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

Tapi bagaimana saya bisa menyingkirkan s: String =>? Saya ingin sesuatu seperti itu:

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

Saya kira kompiler membutuhkan barang ekstra untuk menyimpulkan tipe.

Kita dapat menggabungkan Bagaimana cara mendefinisikan operator terner di Scala yang mempertahankan token terkemuka? dengan jawaban untuk Apakah Opsi membungkus nilai pola yang baik? mendapatkan

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

Apakah ini cukup untuk kebutuhan Anda?

Dari Blog Lambda Tony Morris :

Saya sering mendengar pertanyaan ini. Ya, itu benar. Alih-alih c ? p : q, itu tertulis if(c) p else q.

Ini mungkin tidak disukai. Mungkin Anda ingin menulisnya menggunakan sintaks yang sama dengan Java. Sayangnya, Anda tidak bisa. Ini karena :bukan pengenal yang valid. Jangan takut |! Apakah Anda akan menerima ini?

c ? p | q

Maka Anda membutuhkan kode berikut. Perhatikan =>anotasi panggilan-oleh-nama ( ) pada argumen. Strategi evaluasi ini diperlukan untuk menulis ulang operator terner Java dengan benar. Ini tidak dapat dilakukan di Java sendiri.

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

Berikut adalah contoh penggunaan operator baru yang baru saja kita tentukan:

object T {   val condition = true

  import Bool._

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

Selamat bersenang-senang ;)

Jawaban Rex Kerr diekspresikan dalam Scala dasar:

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

meskipun saya tidak yakin bagian mana dari konstruksi if – else yang ingin Anda optimalkan.

Karena konstruksi if-else di Scala mengembalikan nilai, Anda dapat menggunakan ini

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

Info lebih lanjut: https://alvinalexander.com/scala/scala-if-then-ternary-operator-cookbook-examples

Karena: dengan sendirinya tidak akan menjadi operator yang valid kecuali Anda baik-baik saja dengan selalu meloloskannya dengan tanda centang belakang :, Anda dapat menggunakan karakter lain, misalnya "|" seperti di salah satu jawaban di atas. Tapi bagaimana dengan elvis dengan jenggot? ::

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

Tentu saja ini lagi tidak akan berfungsi jika nilai Anda adalah daftar, karena mereka memiliki :: operator sendiri.