如何“应用”无参数函数的结果

Question

这有效：

List(3, 1, 2).sorted apply 1
res1: Int = 2

这有效：

var x = List(3, 1, 2).sorted
x: List[Int] = List(1, 2, 3)
x(1)
res2: Int = 2

但这不是：

List(3, 1, 2).sorted (1)

error: type mismatch;
 found   : Int(1)
 required: Ordering[?]
       List(3, 1, 2).sorted (1)
                             ^

甚至括号也不能解析解析器到我想要的东西：

(List(3, 1, 2).sorted)(1)

error: type mismatch;
 found   : Int(1)
 required: Ordering[?]
       (List(3, 1, 2).sorted)(1)

这似乎是一种自然的表达。 我究竟做错了什么？

Answer 1

这有效：

(Listed(3, 1, 2).sorted _)(1) ，

但我不确定使用它是否比使用起来更方便：

Listed(3, 1, 2).sorted apply 1 。

无论如何我会选择后者。

Answer 2

我认为你必须保留申请。 原因是排序不是 “无参数”，它被定义为

def sorted [B >: A] (implicit ord: Ordering[B]) : List[A]

由于这是一个隐式参数，Ordering [Int]通常是自动提供的，但是如果你使用parens，编译器会认为你想要指定另一个Ordering [Int]（让我们说倒退）。

Answer 3

可以通过以下方式提供所需的参数：

List(3, 1, 2).sorted(implicitly[Ordering[Int]])(1)

虽然使用apply（）看起来更短，更不可怕。

Answer 4

你能做到的最短 - 不是没有很小的性能损失 - 是

class Allow_\[A](a: A) { def \ = a }
implicit def allowEveryone[A](a: A) = new Allow_\[A](a)

scala> List(1,3,2).sorted\(1)
res0: Int = 2

如果你可以接受另一个角色，这可能会更好：无论如何， <>看起来像是parens，并且可以读作“请填写像往常一样的隐式参数”：

class Allow_<>[A](a: A) { def <> = a }
implicit def allowEveryone[A](a: A) = new Allow_<>[A](a)

scala> List(1,3,2).sorted<>(1)
res0: Int = 2