Konkatenationsoperator nicht verstehen (++)

Question

Ich habe eine Frage zur Listenverkettung. Die Funktion plus plus (++) Arbeit ist anders mit Klammern

(++ "abc") ("xyz") >>> it's xyzabc 
(++) "abc" "xyz" >>> it's abcxyz 

---

Ich denke, es ist, weil:

(++ "abc") ("xyz") >>> "xyz" ++ "abc" 
(++) "abc" "xyz" >>> "abc" ++ "xyz" 

Aber warum, und jedes Dokument die Rede, dass etwa haben?

Ich fahre fort, mit "Subtrahieren" Funktion zu testen. Das Ergebnis, wie mein erwarten:

(subtract 10) (5) >>> -5 
(subtract) 10 5 >>> -5 

Answer 1

Da ++ ein Operator ist, Haskell es in Infix Lage sein, erwartet. Durch Hinzufügen von Parens auf beiden Seiten wird Haskell angewiesen, es als Präfix-Funktion zu behandeln. Deshalb funktioniert

(++) "abc" "xyz"  -- "abc" ++ "xyz" 

funktioniert so wie es tut. Allerdings nur auf einer Seite eines Bedieners ein paren mit, wie (++ "abc") oder ("abc" ++) ist etwas genannt besondere ein section - es erzeugt im Wesentlichen eine Funktion, die „füllen“ das fehlende Argument

(++ "abc")  -- equivalent to `\x -> x ++ "abc"` 
("abc" ++)  -- equivalent to `\x -> "abc" ++ x` 

Dann würde, (++ "abc") ("xyz") entspricht zu (\x -> x ++ "abc") ("xyz") entspricht "xyz" ++ "abc".

Answer 2

Beginnen wir mit dem zweiten. Dies ist ein Fall von Präfix Notation. Hier, und wenn Sie die prefix notation der Verwendung von Operatoren kennen, würden Sie das Ergebnis "abcxyz" sehen, um intuitiver zu sein. Bei dieser Darstellung operativer Ausdrücke steht der Operator im Vordergrund, gefolgt von der Operandenfolge, die in diesem Fall zwei ist. So behandelt es "abc" als den ersten Operanden und "xyz" als den zweiten Operanden und führt die Verkettung in der erwarteten Standardweise durch, d. H. Der zweite/rechte Operand wird rechts von dem ersten/linken Operanden hinzugefügt.

Während der erste ist ein Fall von currying. Grundsätzlich kann die Verkettung (++), die eine Mehrfachargumentfunktion ist, gleichermaßen als eine Reihe von Argumentfunktionen ausgedrückt werden, wobei wir durch die Bereitstellung von jeweils einem Argument unsere ursprüngliche Funktion transformieren, die n Argumente benötigt (besser "Ausdruck" lesen). wie in Haskell) in eine andere Funktion, die n-1 Argumente nimmt. Hier wird also die ursprüngliche 2-Argument-Funktion (++) in eine 1-Argument-Funktion (++ "abc") umgewandelt. Jetzt kann es als eine Funktion gelesen werden, die "abc" an irgendeine als Eingabe bereitgestellte Zeichenkette anfügt, was auch durch unsere Ausgabe bestätigt wird.