Różnice w "prozie" i "notacji kropkowej" podczas wywoływania metody z (jawnymi) niejawnymi parametrami

Question

Nie jestem ekspertem od Scala i jestem zdezorientowany co do składni wywołania metody z niejawnym parametrem.

Oto moja sytuacja:

Mam RDD Spark takiego:

val myData: RDD[Array[String]] = ... 

i określiły zamawiania dla niego:

object MyOrdering extends Ordering[Array[String]] = ... 

Chcę, aby filtrować tę RDD i podjąć górne n wpisów w RDD według mojego zamówienia. Iskra RDD ma sposobu podejmowania najlepszymi wpisy N z tym podpisem:

def top(num: Int)(implicit ord: Ordering[T]): Array[T] 

Początkowo próbowałem ten kod

myData filter { D => 
    D(9) == "yes" 
} top(50)(MyOrdering) 

która nie z tego błędu:

error: Int(50) does not take parameters 
    } top(50)(MyOrdering) 

jednak ten kod działa:

myData.filter(D => D(9) == "yes").top(50)(MyOrdering) 

Na pierwszy rzut oka próbka kodu uszkodzonego i działająca próbka kodu wyglądają tak, jakby określały logikę równoważną. Czy ja tu się mylę? Czy właściwie robię coś innego w dwóch próbach kodu? Czy jest to problem z tym, jak kompilator Scala analizuje kod?

Answer 1

Można zastąpić kropkę . spacją wywołania metody, gdy metoda jest arity-1 (lista parametrów 1) lub arity-0 (brak list parametrów). Na przykład, to nie trafia do kompilacji:

class Foo { 
    def baz(x: Int)(y: Int) = this 
    def qux(x: Int) = this 
} 

(new Foo) baz(1)(1) //Does not compile 
(new Foo).baz(1)(1) //Allowed 
(new Foo) qux(1) //Allowed, since qux is arity-1 
(new Foo).qux(1) //Also allowed, of course 

Gdy lista ostatni parametr jest implicit kompilator może traktować metodę z n listach parametrów jakby to ma arity n-1 jeśli metoda jest wywoływana z implicit argumentu:

class Foo { 
    def baz(x: Int)(implicit y: Int) = this 
} 

implicit val y: Int = 1 
(new Foo) baz(1) //Allowed 
(new Foo).baz(1) //Also fine 
(new Foo) baz(1)(2) //Still not allowed 
(new Foo).baz(1)(2) //Still allowed 

Przeczytaj więcej o zasadach wywoływania metod w the style guide.