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

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

4 个答案: