Kategorie Essay

Posted on by Clemmons

Kategorie Essay




----



Implizite Parameter

Der Datentyp für implizite Parameter ist ein Tupel des Werts zusammen mit einer Suchfunktion, die den Wert eines impliziten Parameters mit dem angegebenen Namen zurückgibt:

Die Funktion gibt den Wert zurück (und ignoriert die impliziten Parameter).

In duplizieren wir die impliziten Parameter in und, wir rufen die Funktion mit der ersten Menge auf und wir geben eine comonad mit dem resultierenden Wert und der zweiten Menge impliziter Parameter zurück:

Die Operation kombiniert die beiden Suchfunktionen und erstellt zwei Kopien. Wir benötigen auch eine spezielle Funktion, um den Wert eines impliziten Parameters zu erhalten:

Die Coeffect-Annotationen sagen uns, welche impliziten Parameter verfügbar sind und alle Operationen der Coeffect-Algebra sind \ (\ cup \).

Datenflussberechnungen

Der Datentyp für Datenflussberechnungen ist eine nicht leere Liste, aber um das Beispiel einfacher zu halten, schreiben wir es einfach als Liste:

Die Operation gibt den Kopf zurück, weshalb wir eine nicht leere Liste benötigen! Die Operation nimmt eine Liste und erzeugt eine Liste gleicher Länge. Es wird getan, indem man auf alle anwendet Suffixe:

produziert. Die Operation ist und dupliziert einfach die Liste.

Eine spezielle Operation verschiebt die Liste um 1 Element in die Vergangenheit:

Die Coeffect-Annotationen repräsentieren die Anzahl der benötigten Werte in der Vergangenheit.





Wenn Sie schreiben, benötigen Sie keine vorherigen Werte (nur die aktuelle), aber wenn Sie sagen, greifen Sie auf einen früheren Wert zu. In der Koeffektivalgebra sind \ ({\ color {coeff} {\ circledast}}, {\ color {coeff} {\ wedge}}, {\ color {coeff} {\ oplus}} \) \ (+, \ Text {min}, \ Text {max} \).

Mehrere Artikel
Vereinigungsfall IP.IP: 'a * (string -> obj) -> IP <' a>

--------------------
Geben Sie IP <'a> = | ein IP von 'a * (string -> obj)

Vollständiger Name: Document.IP <_>

Mehrere Artikel
Wert Zeichenfolge: Wert: 'T -> Zeichenfolge

Vollständiger Name: Microsoft.FSharp.Core.Operators.string

--------------------
Geben Sie Zeichenfolge = System.String ein

Vollständiger Name: Microsoft.FSharp.Core.string

Geben Sie obj = System.Object ein

Vollständiger Name: Microsoft.FSharp.Core.obj

Val Counit: IP <'a> ->' a

Vollständiger Name: Document.counit

val v: 'a

val cobind: f: (IP <'a> ->' b) -> IP <'a> -> IP <' b>

Vollständiger Name: Document.cobind

Wert f: (IP <a> -> 'b)

val p: (string -> obj)

val p1: (string -> obj)

val p2: (string -> obj)

val lookup: name: string -> IP <'a> -> obj

Vollständiger Name: Document.lookup

Wertname: Zeichenfolge

Wert f: (String -> Obj)

Mehrere Artikel
Vereinigungsfall DF.DF: 'eine Liste -> DF <' a>

--------------------
Geben Sie DF <'a> = | ein DF von 'einer Liste

Vollständiger Name: Document.DF <_>

Geben Sie 'T-Liste = Liste <' T> ein

Vollständiger Name: Microsoft.FSharp.Collections.list <_>

Val Counit: DF <'a> ->' a

Vollständiger Name: Document.counit

val cobind: f: (DF <a> -> 'b) -> _arg1: DF <a> -> DF <b>

Vollständiger Name: Document.cobind

Wert f: (DF <a> -> 'b)

val x: 'a

val xs: 'eine Liste

val tl: 'b Liste

Wert prev: DF <'a> -> DF <' a>

Vollständiger Name: Document.prev

val vs: 'eine Liste

Implizite Parameter

Sehen wir uns zunächst einige Beispiele an, die implizite Parameter verwenden.

Der erste ist bereits geladen und übersetzt!

Code für den Zugriff auf einen impliziten Parameter wird in einen Aufruf der Funktion übersetzt. Die Werte, die Sie auf der Benutzungsoberfläche eingeben, werden als spezieller Wert übergeben.

Wenn Sie mehrere implizite Parameter verwenden, wird das Grundelement verwendet, um den Kontext zwischen und zu teilen.

Jeder enthält nur die erforderlichen Parameter.

Wenn wir eine Funktion definieren, wird der Eingabekontext zuerst mit dem verknüpft, der an den Eingang der Funktion angehängt ist. Die Variable befindet sich in der Quelle, aber in der Übersetzung. Alle Parameter werden vom Aufrufer benötigt und bleiben bei der Eingabe der Funktion erhalten.

Dies ist der interessanteste Fall, da er lokal gebunden ist, aber definiert werden muss, wenn die Funktion später aufgerufen wird.

Die erste Zeile ist nicht interessant, aber die zweite Zeile definiert, welche alle Parameter (es gibt keine) mit einer neuen Zuweisung für.

Die Funktion fusioniert dann mit - die erste enthält den Wert für und die andere den Wert für. Danach wird der Kontext erneut aufgeteilt und wir greifen auf beide Parameter getrennt zu.

Laden Sie eines der Samples auf der linken Seite (oder höher) für einfache Demos, oder wählen Sie eine Sprache und schreiben Sie Ihr eigenes Snippet!

Im folgenden formatierten Code können Sie Arten von Variablen in einer QuickInfo anzeigen.

Curry-Funktionen mit mehreren definierten Parametern und Funktionen werden erweitert.

Flacher Datenfluss

Die Übersetzung für den Flat-Datenfluss ist dieselbe wie für implizite Parameter.





Eine Sache, die wir vorher nicht besprochen haben, ist der Umgang mit Variablen:

Variablen werden in einem Tupel im Wert übergeben und zusammen mit und extrahiert, um den richtigen zu finden.

Das Schlüsselwort wird der Operation zugeordnet, die einen Comonad-Wert mit \ (n \) früheren Werten in eins mit \ (n-1 \) früheren Werten umwandelt (den aktuellen Wert fallen lässt).

Im flachen Datenfluss behalten wir eine Annotation für den gesamten Kontext bei, da wir für alle Variablen im Kontext die gleiche Anzahl vergangener Werte benötigen.

Sie sind alles nur Elemente eines großen Tupels!

Jetzt können Sie sehen, warum wir 1 früheren Wert von beiden und benötigen.

Wir führen zuerst alle Variablen in einen einzigen Kontextwert zusammen. Da wir dann einen vorherigen Wert der Variablen benötigen, benötigen wir auch einen letzten Wert von. Dies ist, weil verhält sich wie und es benötigt zwei Listen der gleichen Länge.

Struktureller Datenfluss

Im strukturellen Datenfluss funktionieren die Dinge ein bisschen anders.

Wir haben Annotationen für einzelne Variablen im Kontext.Zum Beispiel wird ein Kontext, der enthält und wo wir den aktuellen Wert von und einen Wert von benötigen, wie folgt dargestellt:

Die Variablen und sind in verschmolzen. Der Anfangskontext ist jetzt und enthält ein leeres Tupel von Variablen mit einem leeren Vektor von Anmerkungen, die als geschrieben werden.

Um eine Teilmenge von Variablen aus einem Kontext auszuwählen, verwenden wir jetzt eine Familie von Operationen, bei denen der Index angibt, welche der Variablen aus dem Kontext, den wir extrahieren möchten (bedeutet halten, dh ablegen).

Der Ort, wo Dinge werden Ja wirklich interessant ist, wenn wir Funktion Anwendung haben. Im Folgenden wird eine Hilfsfunktion aufgerufen, die auf den vorherigen Wert ihres Arguments auf einem früheren Wert zugreift:

Wir benötigen zwei vergangene Werte von und einen vergangenen Wert von.

In der Übersetzung trägt der Wert zwei Vergangenheitswerte von. Die Funktion wird dann mit einem von erzeugtem Argument aufgerufen. Hier müssen beide und müssen einen Wert in der Vergangenheit haben und die Anforderungen hinzufügen (das ist das \ (+ \) in der Koeffektivalgebra)!





Aufmerksamkeit auf




Top

Leave a Reply