In der Mathematik und Informatik sind höherwertige Funktionen, funktionelle Formen oder functionals Funktionen, die mindestens einen des folgenden tun:

• nehmen Sie eine oder mehr Funktionen als ein Eingang
• Produktion eine Funktion

Alle anderen Funktionen sind die ersten Ordnungsfunktionen. In der Mathematik sind höherwertige Funktionen auch bekannt als Maschinenbediener oder functionals. Die Ableitung in der Rechnung ist ein allgemeines Beispiel, da es eine Funktion zu einer anderen Funktion kartografisch darstellt.

In der ungetippten Lambda-Rechnung sind alle Funktionen höherwertig; in einer getippten Lambda-Rechnung, von der die meisten funktionellen Programmiersprachen abgeleitet werden, sind höherwertige Funktionen Werte mit Typen der Form.

Die auf vielen funktionellen Programmiersprachen gefundene Funktion ist ein Beispiel einer höherwertigen Funktion. Es nimmt als Argumente eine Funktion f und eine Liste von Elementen, und als Ergebnis, geben eine neue Liste mit f zurück, der auf jedes Element von der Liste angewandt ist. Eine andere sehr allgemeine Art der höherwertigen Funktion auf jenen Sprachen, die sie unterstützen, sortiert Funktionen, die eine Vergleich-Funktion als ein Parameter nehmen, dem Programmierer erlaubend, den Sortieren-Algorithmus von den Vergleichen der Sachen zu trennen, die sortieren werden. Die C Standardfunktion, ist ein Beispiel davon.

Andere Beispiele von höherwertigen Funktionen schließen Falte, Funktionszusammensetzung, Integration und die Funktion der unveränderlichen Funktion λx.λy.x ein.

Die folgenden Beispiele waren nicht beabsichtigt, um Programmiersprachen zu vergleichen und ihnen gegenüberzustellen, da jedes Programm eine verschiedene Aufgabe durchführt. Außerdem ist die Idee von "scripting Sprache" außer dem Spielraum dieses Artikels.

Beispiel

Dieses Pythonschlange-Programm enthält die höherwertige Funktion g , der eine Funktion als sein erstes Argument nimmt und eine Zahl zurückgibt. Dieses Beispiel druckt 100 (g (f, 7) = (7+3) × (7+3)).

def f (x):

geben Sie x + 3 zurück

def g (Funktion, x):

geben Sie Funktion (x) * Funktion (x) zurück

drucken Sie g (f, 7)

</Quelle>

In diesem Schema-Beispiel nimmt die höherwertige Funktion g eine Zahl und gibt eine Funktion zurück. Die Funktion nimmt eine Zahl und Umsatz diese Zahl plus 7. (z.B (3) =10).

(definieren Sie (g x)

(Lambda (y) (+ x y)))

(definieren Sie (g 7))

(Anzeige (3))

</Quelle>

In diesem Beispiel von Erlang nimmt die höherwertige Funktion or_else/2 eine Liste von Funktionen (Fs) und Argument (X). Es bewertet die Funktion F mit dem Argument X als Argument. Wenn die Funktion F Umsatz falsch dann die folgende Funktion in Fs bewertet wird. Wenn die Funktion F Umsatz {falsch Y} dann die folgende Funktion in Fs mit dem Argument Y bewertet wird. Wenn die Funktion F R zurückgibt, wird die höherwertige Funktion or_else/2 R zurückgeben. Bemerken Sie, dass X Y und R Funktionen sein kann. Falscher Beispiel-Umsatz.

or_else ([], _)-> falsch;

or_else ([F | Fs], X)-> or_else (Fs, X, F (X)).

or_else (Fs, X, falsch)-> or_else (Fs, X);

or_else (Fs, _, {falsch, Y})-> or_else (Fs, Y);

or_else (_, _, R)-> R.

or_else ([Spaß erlang:is_integer/1, Spaß erlang:is_atom/1, Spaß erlang:is_list/1], 3.23).

</Quelle>

Alternativen

Programmiersprachen, die Funktionszeigestöcke als Funktionsrahmen unterstützen, können mit höherwertigen Funktionen wetteifern. Solche Sprachen schließen den C und C ++ Familie ein. Ein Beispiel ist der folgende C-Code, der eine Annäherung des Integrals einer willkürlichen Funktion schätzt:

//Schätzen Sie das Integral von f innerhalb des Zwischenraums [a, b]

verdoppeln Sie sich integriert (doppelt (*f) (verdoppeln Sie x), verdoppeln Sie a, verdoppeln Sie b)

{\

verdoppeln Sie Summe, dt;

interne Nummer i;

//Numerische Integration: 0th bestellen Annäherung

resümieren Sie = 0.0;

dt = (b - a) / 100.0;

für (ich = 0; ich

Ein anderes Beispiel ist die Funktion qsort von der C Standardbibliothek.

Auf anderen befehlenden Programmiersprachen ist es möglich, einige derselben algorithmischen Ergebnisse zu erreichen, wie durch den Gebrauch von höherwertigen Funktionen durch die dynamische Durchführung des Codes erhalten werden (manchmal hat "Eval" genannt, oder "Führen Sie" Operationen "Durch") im Rahmen der Einschätzung. Es kann bedeutende Nachteile zu dieser Annäherung geben:

• Der durchzuführende Argument-Code wird gewöhnlich nicht statisch getippt; diese Sprachen verlassen sich allgemein auf das dynamische Schreiben, um gut-formedness und Sicherheit des durchzuführenden Codes zu bestimmen.
• Das Argument wird gewöhnlich als eine Schnur zur Verfügung gestellt, deren Wert bis zur Durchlaufzeit nicht bekannt sein darf. Diese Schnur muss entweder während der Programm-Ausführung kompiliert (gerade rechtzeitig Kompilation verwendend), oder durch die Interpretation bewertet werden, das Verursachen von einigen hat oben an der Durchlaufzeit beigetragen, und gewöhnlich weniger effizienten Code erzeugend.

Makros können auch verwendet werden, um einige der Effekten von höheren Ordnungsfunktionen zu erreichen. Jedoch können Makros nicht das Problem der variablen Festnahme leicht vermeiden; sie können auch in großen Mengen vom kopierten Code resultieren, der für einen Bearbeiter schwieriger sein kann zu optimieren. Makros werden allgemein nicht stark getippt, obwohl sie stark getippten Code erzeugen können.

Auf objektorientierten Programmiersprachen, die höherwertige Funktionen nicht unterstützen, können Gegenstände ein wirksamer Ersatz sein. Eine Methode-Tat eines Gegenstands hauptsächlich wie Funktionen und eine Methode kann Gegenstände als Rahmen akzeptieren und Gegenstände als Rückwerte erzeugen. Gegenstände tragen häufig hinzugefügte Durchlaufzeit oben im Vergleich zu reinen Funktionen, jedoch, und hinzugefügtem Textbaustein-Code, um einen Gegenstand und seine Methode (N) zu definieren und zu realisieren. Sprachen, die Stapel-basiert (gegen den Haufen-basierten) Gegenstände oder structs erlauben, können mehr Flexibilität mit dieser Methode versorgen.

Ein Beispiel, einen einfachen Stapel zu verwenden, hat Aufzeichnung in Freiem Pascal mit einer Funktion gestützt, die eine Funktion zurückgibt:

Programm-Beispiel;

Typ

interne Nummer = ganze Zahl;

Txy = registrieren x, y: interne Nummer; Ende;

Tf = Funktion (xy: Txy): interne Nummer;

fungieren Sie f (xy: Txy): interne Nummer;

beginnen Sie

Ergebnis: = xy.y + xy.x;

Ende;

fungieren Sie g (func: Tf): Tf;

beginnen Sie

Ergebnis: = func;

Ende;

var

a: Tf;

xy: Txy = (x: 3; y: 7);

beginnen Sie

a: = g (@f);//geben eine Funktion in "einen" zurück

writeln ((xy));//druckt 10

Ende.

</Quelle>

Die Funktion nimmt eine Aufzeichnung als Eingang und gibt den Wert der ganzen Zahl der Summe der Aufzeichnung und Felder (3 + 7) zurück.

Siehe auch

• Erstklassige Funktion
• Logik von Combinatory
• Funktionsniveau, programmierend
• Funktionelle Programmierung
• Rechnung von Kappa - ein Formalismus für Funktionen, der höherwertige Funktionen ausschließt
• Strategie-Muster
• Höhere Ordnungsnachrichten

Links

• Höherwertige Funktionen und abweichende Rechnung
• Zunahme-Lambda-Bibliothek für C ++
• Höhere Ordnung Perl