Wenn der Pipe-Operator so erstellt wird:
%Vor%Und so benutzt:
%Vor%Dann scheint es List.Map zu nehmen und es hinter sich zu lassen (fun x - & gt; x * x * x) Und ändert nichts an der Position von [2; 4; 6]
So sieht es jetzt so aus:
%Vor%Dies funktioniert jedoch nicht.
Ich lerne gerade f # zum ersten Mal. Und das störte mich beim Lesen eines Buches über f #. So könnte ich lernen, was ich später vermisse, aber ich entschied mich trotzdem zu fragen.
Es ist jedoch offensichtlich, dass mir etwas Wichtiges fehlt. Da kann ich den Pfeifenbediener einfach neu erstellen. Aber ich verstehe nicht, warum es funktioniert. Ich könnte mich sehr bald blamieren, wenn ich mehr lerne. Na gut.
Der Pipe-Operator ist einfach syntaktischer Zucker für verkettete Methodenaufrufe. Es ist sehr ähnlich wie linq Ausdrücke in C # ausgedrückt werden.
Erklärung von hier :
Vorwärtiger Rohrleitungsbetreiber Ich liebe diesen Kerl. Der Forward-Pipe-Operator wird einfach wie folgt definiert:
%Vor%Und hat eine Typ-Signatur:
%Vor%Was bedeutet: Bei einem generischen Typ 'a und einer Funktion, die ein' a 'und' a 'zurückgibt, geben Sie die Anwendung der Funktion an die Eingabe zurück.
Anstatt das zu erklären, möchte ich Ihnen ein Beispiel geben, wo es verwendet werden kann:
%Vor%Der Code ist sehr geradlinig, aber beachte, wie unbändig die Syntax aussieht. Alles, was wir tun wollen, ist, das Ergebnis einer Berechnung zu nehmen und es an die nächste Berechnung zu übergeben. Wir könnten es umschreiben, indem wir eine Reihe neuer Variablen einführen:
%Vor%Aber jetzt müssen Sie alle diese temporären Variablen gerade halten. Was der Operator (| & gt;) tut, ist einen Wert anzunehmen und an eine Funktion "weiterzuleiten", so dass Sie im Wesentlichen den Parameter einer Funktion vor dem Funktionsaufruf angeben können. Dies vereinfacht den F # -Code erheblich, da Sie Funktionen zusammenführen können, wobei das Ergebnis von einem in das nächste übernommen wird. Um das gleiche Beispiel zu verwenden, kann der Code wie folgt geschrieben werden:
%Vor%Bearbeiten :
In F # nehmen Sie mit einem Methodenaufruf eine Funktion und wenden sie dann auf den folgenden Parameter an. In Ihrem Beispiel wäre also List.map (fun x -> x * x * x) auf [2;4;6] anzuwenden. Alles, was der Pipe-Operator tut, ist, die Parameter in umgekehrter Reihenfolge zu übernehmen und dann die Anwendung rückgängig zu machen.
: List.map (fun x -> x * x * x)
Parameter: [2;4;6]
Standard F # Aufrufsyntax: f g
Umgekehrte F # -Aufrufsyntax: g f
Standard:
%Vor%Umgekehrt:
%Vor%Wie andere bereits gesagt haben, missverstehen Sie im Grunde, zu welchem Ergebnis2 es führen würde. Es würde tatsächlich zu
auflösen List.map (fun x -> x * x * x) [2;4;6]
List.map benötigt zwei Argumente: eine Funktion, die auf alle Elemente in einer Liste und einer Liste angewendet wird. (fun x -> x * x * x) ist das erste Argument und [2;4;6] ist das zweite Argument.
Im Grunde genommen stellst du einfach links von |> nach dem Ende dessen, was auf der rechten Seite steht.
Wenn Sie Ihre Definition von Projizieren Sie jetzt diese Signatur auf Ihren Ausdruck |> in fsi eingeben und die Signatur des Operators betrachten, die durch Typinferenz abgeleitet wurde, bemerken Sie val ( |> ) : 'a -> ('a -> 'b) -> 'b , dh das Argument 'a wird der Funktion ('a -> 'b) rendies 'b . [2;4;6] |> List.map (fun x -> x * x * x) und Sie erhalten List.map (fun x -> x * x * x) [2;4;6] , wobei das Argument die Liste [2;4;6] ist und die Funktion angewandte Funktion eines Arguments List.map (fun x -> x * x * x) .
Tags und Links f#