Warum bietet Scala sowohl mehrere Parameterlisten als auch mehrere Parameter pro Liste?

Question

Mehrere Parameterlisten, z.B. def foo(a:Int)(b:Int) = {} und mehrere Parameter pro Liste, z.B. def foo(a:Int, b:Int) = {} sind semantisch gleichwertig, soweit ich das beurteilen kann, und die meisten funktionalen Sprachen haben nur eine Möglichkeit, mehrere Parameter zu deklarieren, z. F #.

Der einzige Grund, warum ich beide Stile von Funktionsdefinitionen unterstützen kann, ist syntaxähnliche Spracherweiterungen mit einer Parameterliste, die nur einen Parameter enthält.

def withBufferedWriter(file: File)(block: BufferedWriter => Unit) 

kann nun mit der Syntax-Suche

withBufferedWriter(new File("myfile.txt")) { out => 
    out write "whatever" 
    ... 
} 

jedoch genannt werden, könnte es andere Möglichkeiten, die Verwendung von geschweiften Klammern unterstützen, ohne dass mehrere Parameterlisten zu haben.

Eine verwandte Frage: Warum wird die Verwendung von mehreren Parameterlisten in Scala "currying" genannt? Gewöhnlich wird Currying als eine Technik definiert, um eine n-ary-Funktion zum Unterstützen einer teilweisen Anwendung unförmig zu machen. In Scala kann man jedoch teilweise eine Funktion anwenden, ohne eine "curried" Version (mehrere Parameterlisten mit jeweils einem Parameter) der Funktion zu erstellen.

Answer 1

Es macht Dich in der Lage zB zu tun:

scala> def foo(as: Int*)(bs: Int*)(cs: Int*) = as.sum * bs.sum * cs.sum 
foo: (as: Int*)(bs: Int*)(cs: Int*)Int 

scala> foo(1, 2, 3)(4, 5, 6, 7, 9)(10, 11) 
res7: Int = 3906 

Answer 2

Sie zu beantworten, „damit verbundene Frage,“ currying ist einfach eine Möglichkeit, eine Funktion von mehreren Argumenten Drehen, zum Beispiel (A, B, C) => D, in eine Funktion, die man braucht Argument und gibt eine Funktion, z A => (B => (C => D)) (Klammern sind gezeigt, aber nicht notwendig).

Die tupelisierte Form und die Curryform sind isomorph, und wir können zwischen ihnen frei übersetzen. All dies sind gleichwertig, haben aber unterschiedliche syntaktische Implikationen:

(A, B, C, D, E) => F 
((A, B), (C, D, E)) => F 
(A, B) => (C, D, E) => F 

Wenn Sie separate Parametergruppen erklären, dies ist die Art von currying ist Sie tun. Das Multi-Parameter-Gruppe ist ein Verfahren, das eine Funktion gibt ... Sie dies in der REPL zu sehen:

scala> def foo(a:Int, b:Int)(c:Int, d:Int, e:Int):Int = 9 
foo: (a: Int,b: Int)(c: Int,d: Int,e: Int)Int 

scala> foo _            
res4: (Int, Int) => (Int, Int, Int) => Int = <function2> 

Answer 3

Neben dem Sie Methoden zu schreiben, wie ein Teil der Sprache aussehen (die Sie bereits entdeckt), es ist erwähnenswert, dass der Typ-Inferenzrechner mit jeweils einem Block arbeitet.

So in dieser:

def foo[T](a: T, b: T)(op: (T,T)=>T) = op(a,b) 
foo(1,2){_+_} 

T wird zunächst als Int abgeleitet werden, die dann als Typ der zwei Unterstrichen im Verschluss verwendet werden. So weiß der Compiler bei vollständiger Typsicherheit, dass die Operation + gültig ist.

Answer 4

Ich weiß, eine der Motivationen war implizite Parameterlisten. "implizit" ist eine Eigenschaft der Liste, nicht der Parameter. Eine andere war wahrscheinlich Fallklassen: Nur die erste Parameterliste wird zu Fallfeldern.

Answer 5

Zurück Referenzen in Standardargumente:

case class Foo(bar: Int) 

def test(f: Foo)(i: Int = f.bar) = i*i 

test(Foo(3))()