三元运算符类似于?:

我试图避免像这样的结构:

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

好的,在这个例子中, thenelse分支很简单,但是可以复杂的图像。 我build立了以下内容:

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

定义,我可以用上面的简单例子replace:

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

但是我怎样才能摆脱s: String => ? 我想要这样的东西:

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

我想编译器需要额外的东西来推断types。

我们可以结合如何定义一个三元运算符在斯卡拉保存主要的令牌? 与select包装价值的一个很好的模式的答案? 要得到

 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 

这是否足以满足您的需求?

来自Tony Morris的Lambda博客 :

我听到这个问题很多。 是的,它确实。 而不是c ? p : q c ? p : q ,写成if(c) p else q

这可能不是最好的。 也许你想使用与Java相同的语法来编写它。 可悲的是,你不能。 这是因为:不是有效的标识符。 不怕, | 是! 你能解决这个问题吗?

 c ? p | q 

那么你需要下面的代码。 注意参数上的名称( => )注释。 这个评估策略需要正确地重写Java的三元运算符。 这不能在Java本身完成。

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

这里是一个使用我们刚定义的新运算符的例子:

 object T { val condition = true import Bool._ // yay! val x = condition ? "yes" | "no" } 

玩的开心 ;)

雷克斯·克尔的回答表示在基本的斯卡拉:

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

尽pipe我不确定你想优化if-else结构的哪一部分。

因为:本身不会是一个有效的操作符,除非你总是用后面的剔除符逃脱它:你可以用另一个字符,例如“|” 如上面的答案之一。 但是山羊胡呢呢?

 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 

当然,如果你的值是列表,这又是不行的,因为它们自己有::操作符。