如何在 Scala 中定义保留前导标记的三元运算符？

Question

我正在编写一个生成 Scala 输出的代码生成器。

我需要以这样的方式模拟三元运算符，即导致“？”的标记保持完好无损。

例如转换表达式 c ? p : q 到 c 某事。简单的 if(c) p else q 不符合我的标准，因为它需要将 if( 放在 c 之前。

我的第一次尝试（仍然使用 c /p/q 如上所述）是

c match { case(true) => p; case _ => q }

我发现的另一个选项是：

class ternary(val g: Boolean => Any) { def |: (b:Boolean) = g(b) }

implicit def autoTernary (g: Boolean => Any): ternary = new ternary(g)

它允许我写：

c |: { b: Boolean => if(b) p else q }

我喜欢第二个选项的整体外观，但是有没有办法让它不那么冗长，

谢谢？

Answer 1

即使语法没有按照预期的顺序求值——它将条件绑定到第一个选项！——你也可以像这样创建自己的三元运算符：

class IfTrue[A](b: => Boolean, t: => A) { def |(f: => A) = if (b) t else f }
class MakeIfTrue(b: => Boolean) { def ?[A](t: => A) = new IfTrue[A](b,t) }
implicit def autoMakeIfTrue(b: => Boolean) = new MakeIfTrue(b)

技巧是将 ? 解释为MakeIfTrue 对象上的方法，将条件绑定到要在“true”情况下返回的对象。生成的 IfTrue 对象现在使用 | 方法作为评估条件的请求，如果条件为 true，则返回存储的 true 选项，或者返回刚刚传入的选项如果是假的。

请注意，我使用了诸如 =>; 之类的东西。 A 而不仅仅是 A（按名称参数），以便除非实际使用表达式，否则不会计算表达式。因此，您将只评估您实际需要的一面（就像 if 语句一样）。

让我们看看它的实际效果：

scala> List(1,3,2).isEmpty ? "Empty" | "Nonempty"
res0: java.lang.String = Nonempty

scala> (4*4 > 14) ? true | false
res1: Boolean = true

scala> class Scream(s: String) { println(s.toUpperCase + "!!!!") }
defined class Scream

scala> true ? new Scream("true") | new Scream("false")
TRUE!!!!
res3: Scream = Scream@1ccbdf7

（PS 为了避免与 Actor 库 ? 混淆，您可能应该将其称为 |? 之类的其他名称。）

Answer 2

让我们保持简单：

Java：

tmp = (a > b) ? a : b;

Scala：

tmp = if (a > b) a else b

除了简单之外，它还清晰且快速，因为：不分配不需要的对象，使垃圾收集器不受影响（因为它总是应该如此）并更好地利用处理器缓存。

Answer 3

您可以使用类似这样的

sealed trait TernaryOperand[A] {
  def >(q: => A): A
}

case class TernarySecond[A](val p: A) extends TernaryOperand[A] {
  def >(q: => A) = p
}

case class TernaryThird[A]() extends TernaryOperand[A] {
  def >(q: => A) = q
}

implicit def ternary(c: Boolean) = new {
  def ?[A](p: => A): TernaryOperand[A] = if (c) TernarySecond(p) else TernaryThird()
}

val s1 = true ? "a" > "b"
println(s1) //will print "a"

val s2 = false ? "a" > "b"
println(s2) //will print "b"

代码：此代码将任何布尔值转换为具有名为 ? 的方法的匿名类型。根据布尔值的不同，此方法将返回 TernarySecond 或 TernaryThird。它们都有一个名为 > 的方法，该方法分别返回第二个操作数或第三个操作数。

Answer 4

三元运算符将我的改进添加到 Rex Kerr 和 Michel Kramer 的最佳实现中：

• 我对使用 Scala 的新值类以避免装箱开销进行了改进。
• 对第二个和第三个操作数进行名称调用，以便仅评估所选操作数。
• 米歇尔在第一个（布尔）操作数上按值调用，以避免按名称开销；它总是被评估。
• Rex 的条件具体类以避免任何匿名类开销。
• 米歇尔对条件的评估以确定要构造哪个类，以避免两个参数构造函数的开销。

。

sealed trait TernaryResult[T] extends Any {
  def |(op3: => T): T
}

class Ternary2ndOperand[T](val op2: T) extends AnyVal with TernaryResult[T] {
  def |(op3: => T) = op2
}

class Ternary3rdOperand[T](val op2: T) extends AnyVal with TernaryResult[T] {
  def |(op3: => T) = op3
}

class Ternary(val op1:Boolean) extends AnyVal {
   def ?[A](op2: => A): TernaryResult[A] = if (op1) new Ternary2ndOperand(op2) else new Ternary3rdOperand(op2)
}

object Ternary {
   implicit def toTernary(condition: Boolean) = new Ternary(condition)
}

请注意，相对于 if else 的改进不仅仅是节省了 6 个字符。 Scala IDE 的关键字语法颜色对于 if、else、null 和 true，在某些情况下有更好的对比度（本网站当前呈现的语法着色未显示这一点）：

if (cond) true else null
cond ? true | null