Anonyme Funktion

Im Computerprogrammierung, ein Anonyme Funktion (Funktion wörtlich, Lambda -Abstraktion, Lambda -Funktion, Lambda -Ausdruck oder Block) ist ein Funktion Definition, die nicht gebunden zu einem Kennung. Anonyme Funktionen sind oft Argumente, an die übergeben wird Funktionen höherer Ordnung oder verwendet, um das Ergebnis einer Funktion höherer Ordnung zu konstruieren, die eine Funktion zurückgeben muss.^[1] Wenn die Funktion nur einmal oder eine begrenzte Anzahl von Male verwendet wird, kann eine anonyme Funktion syntaktisch leichter sein als die Verwendung einer benannten Funktion. Anonyme Funktionen sind allgegenwärtig in Funktionale Programmiersprachen und andere Sprachen mit erstklassige Funktionen, wo sie die gleiche Rolle für die erfüllen Funktionstyp wie Literale tun für andere Datentypen.

Anonyme Funktionen entstehen in der Arbeit von Alonzo -Kirche in seiner Erfindung der Lambda -Kalkül, in denen alle Funktionen 1936 vor elektronischen Computern anonym sind. ^[2] In mehreren Programmiersprachen werden anonyme Funktionen mit dem Schlüsselwort eingeführt Lambdaund anonyme Funktionen werden oft als Lambdas- oder Lambda -Abstraktionen bezeichnet. Anonyme Funktionen waren ein Merkmal von Programmiersprachen seit Lispeln Im Jahr 1958 unterstützen eine wachsende Anzahl moderner Programmiersprachen anonyme Funktionen.

Namen

Die Namen "Lambda Abstraktion", "Lambda -Funktion" und "Lambda -Ausdruck" beziehen f(x) = M würde geschrieben sein (λx.M) (M ist ein Ausdruck, der verwendet x). Vergleichen mit der Python -Syntax von lambda x: M.

Der Name "Pfeilfunktion" bezieht sich auf die Mathematik. "Karten zu"Symbol, x ↦ M. Vergleichen mit der JavaScript -Syntax von x => M.^[3]

Verwendet

Anonyme Funktionen können verwendet werden, um Funktionen zu enthalten, die nicht benannt werden müssen, und möglicherweise für kurzfristige Verwendung. Einige bemerkenswerte Beispiele sind Schließungen und Currying.

Die Verwendung anonymer Funktionen ist eine Frage des Stils. Die Verwendung von ihnen ist niemals der einzige Weg, um ein Problem zu lösen. Jede anonyme Funktion kann stattdessen als benannte Funktion definiert und mit Namen aufgerufen werden. Einige Programmierer verwenden anonyme Funktionen, um einen spezifischen, nicht wiederverwendbaren Code zu verkörpern, ohne den Code mit vielen kleinen Einzeilen-normalen Funktionen zu verstreuen.

In einigen Programmiersprachen werden anonyme Funktionen üblicherweise für sehr bestimmte Zwecke wie Bindungsereignisse an Rückrufe oder die Instanziierung der Funktion für bestimmte Werte implementiert, die möglicherweise effizienter, lesbarer und weniger fehleranfällig sein können als eine generischere Funktion, .

Die folgenden Beispiele sind in Python 3 geschrieben.

Sortierung

Wenn Sie versuchen, nicht standardmäßig zu sortieren, ist es möglicherweise einfacher, die Sortierlogik als anonyme Funktion einzudämmen, anstatt eine benannte Funktion zu erstellen. Die meisten Sprachen bieten eine generische Sortierfunktion, die a implementiert Sortieren Sie den Algorithmus Das sortiert willkürliche Objekte. Diese Funktion akzeptiert normalerweise eine willkürliche Funktion, die feststellt, wie man verglichen wird, ob zwei Elemente gleich sind oder ob einer größer oder weniger als der andere ist.

Betrachten Sie diesen Python -Code, der eine Liste von Zeichenfolgen nach Länge der Zeichenfolge sortiert:

>>> a = ['Haus', 'Wagen', 'Fahrrad'] >>> a.Sortieren(Schlüssel=Lambda x: Len(x)) >>> a ['Wagen', 'Fahrrad', 'Haus'] 

Die anonyme Funktion in diesem Beispiel ist der Lambda -Ausdruck:

Lambda x: Len(x) 

Die anonyme Funktion akzeptiert ein Argument, xund gibt die Länge seines Arguments zurück, der dann von der verwendet wird Sortieren() Methode als Kriterien für die Sortierung.

Grundlegende Syntax einer Lambda -Funktion in Python ist

Lambda arg1, arg2, arg3, ...: <Betrieb an das Argumente Rückkehr a Wert> 

Der von der Lambda -Funktion zurückgegebene Ausdruck kann einer Variablen zugewiesen und im Code an mehreren Stellen verwendet werden.

>>> hinzufügen = Lambda a: a + a >>> hinzufügen(20) 40 

Ein weiteres Beispiel wäre, Elemente in einer Liste mit dem Namen ihrer Klasse zu sortieren (in Python, alles hat eine Klasse):

>>> a = [10, 'Nummer', 11.2] >>> a.Sortieren(Schlüssel=Lambda x: x.__Klasse__.__Name__) >>> a [11.2, 10, 'Nummer'] 

Beachten Sie, dass 11.2 hat Klassenname "schweben",", 10 hat Klassenname "int", und 'Nummer' hat Klassenname "str"Die sortierte Reihenfolge ist"schweben","int", dann "str".

Schließungen

Schließungen sind Funktionen, die in einer Umgebung bewertet wurden, die enthält gebundene Variablen. Das folgende Beispiel bindet die Variable "Schwelle" in einer anonymen Funktion, die die Eingabe mit dem Schwellenwert vergleicht.

def Comp(Schwelle):  Rückkehr Lambda x: x < Schwelle 

Dies kann als eine Art Generator für Vergleichsfunktionen verwendet werden:

>>> func_a = Comp(10) >>> func_b = Comp(20) >>> drucken(func_a(5), func_a(8), func_a(13), func_a(21)) WAHR WAHR FALSCH FALSCH >>> drucken(func_b(5), func_b(8), func_b(13), func_b(21)) WAHR WAHR WAHR FALSCH 

Es wäre unpraktisch, für jede mögliche Vergleichsfunktion eine Funktion zu erstellen, und kann zu unpraktisch sein, um den Schwellenwert für die weitere Verwendung zu halten. Unabhängig von dem Grund, warum ein Verschluss verwendet wird, ist die anonyme Funktion die Entität, die die Funktionalität enthält, die den Vergleich macht.

Currying

Currying ist der Prozess des Änderns einer Funktion, so dass es eine einzelne Eingabe anstatt mehrere Eingänge zu nehmen, und eine Funktion zurückgibt, die die zweite Eingabe akzeptiert und so weiter. In diesem Beispiel eine Funktion, die ausgeführt wird Aufteilung von jeder Ganzzahl wird in eine in eine verwandelt, die eine Spaltung durch eine festgelegte Ganzzahl ausführt.

>>> def teilen(x, y): ...  Rückkehr x / y >>> def Divisor(d): ...  Rückkehr Lambda x: teilen(x, d) >>> halb = Divisor(2) >>> dritte = Divisor(3) >>> drucken(halb(32), dritte(32)) 16.0 10.666666666666666 >>> drucken(halb(40), dritte(40)) 20.0 13.333333333333334 

Während die Verwendung anonymer Funktionen beim Currying möglicherweise nicht üblich ist, kann es immer noch verwendet werden. Im obigen Beispiel erzeugt der Funktionsteiler Funktionen mit einem bestimmten Divisor. Die Funktionen der Hälfte und des dritten Curry Die Kluft mit einem festen Divisor.

Die Divisorfunktion bildet auch einen Verschluss durch Bindung der Variablen d.

Funktionen höherer Ordnung

A Funktion höherer Ordnung ist eine Funktion, die eine Funktion als Argument nimmt. Dies wird üblicherweise verwendet, um das Verhalten einer allgemein definierten Funktion anzupassen, häufig ein Schleifenkonstrukt- oder Rekursionsschema. Anonyme Funktionen sind eine bequeme Möglichkeit, solche Funktionsargumente anzugeben. Die folgenden Beispiele finden Sie in Python 3.

Karte

Die Kartenfunktion führt einen Funktionsaufruf in jedem Element einer Liste aus. Das folgende Beispiel Quadrate Jedes Element in einem Array mit einer anonymen Funktion.

>>> a = [1, 2, 3, 4, 5, 6] >>> aufführen(Karte(Lambda x: x*x, a)) [1, 4, 9, 16, 25, 36] 

Die anonyme Funktion akzeptiert ein Argument und multipliziert es von sich selbst (tritt auf). Die obige Form wird von den Schöpfer der Sprache entmutigt, die behaupten, dass die unten dargestellte Form die gleiche Bedeutung hat und mehr mit der Philosophie der Sprache übereinstimmt:

>>> a = [1, 2, 3, 4, 5, 6] >>> [x*x zum x in a] [1, 4, 9, 16, 25, 36] 

Filter

Die Filterfunktion gibt alle Elemente aus einer Liste zurück, die True bewerten, wenn sie an eine bestimmte Funktion übergeben.

>>> a = [1, 2, 3, 4, 5, 6] >>> aufführen(Filter(Lambda x: x % 2 == 0, a)) [2, 4, 6] 

Die anonyme Funktion prüft, ob das daran übergebene Argument gerade ist. Das gleiche wie bei der Karte wird das folgende Formular als angemessener angesehen:

>>> a = [1, 2, 3, 4, 5, 6] >>> [x zum x in a wenn x % 2 == 0] [2, 4, 6] 

Falten

Eine Faltfunktion läuft über alle Elemente in einer Struktur (für Listen normalerweise links nach rechts, eine "linke Falte", die genannt wird reduzieren in Python), wenn er einen Wert ansammelt, wie er geht. Dies kann verwendet werden, um alle Elemente einer Struktur zu einem Wert zu kombinieren, zum Beispiel:

>>> aus Functools importieren reduzieren >>> a = [1, 2, 3, 4, 5] >>> reduzieren(Lambda x,y: x*y, a) 120 

Dies funktioniert

$oder$

Die anonyme Funktion hier ist die Multiplikation der beiden Argumente.

Das Ergebnis einer Falte muss nicht ein Wert sein. Stattdessen können sowohl MAP als auch Filter mit Fold erstellt werden. In MAP ist der angesammelte Wert eine neue Liste, die die Ergebnisse der Anwendung einer Funktion auf jedes Element der ursprünglichen Liste enthält. Im Filter ist der angesammelte Wert eine neue Liste, die nur die Elemente enthält, die der angegebenen Bedingung entsprechen.

Liste der Sprachen

Das Folgende ist eine Liste von Programmiersprachen Diese unterstützt unbenannte anonyme Funktionen vollständig oder teilweise als Variante oder gar nicht.

Diese Tabelle zeigt einige allgemeine Trends. Erstens die Sprachen, die keine anonymen Funktionen unterstützen (C, Pascal, Objekt Pascal) sind alle statisch getippte Sprachen. Statisch getippte Sprachen können jedoch anonyme Funktionen unterstützen. Zum Beispiel die Ml Sprachen werden statisch typisiert und enthalten grundlegend anonyme Funktionen, und Delphi, ein Dialekt von Objekt Pascal, wurde erweitert, um anonyme Funktionen zu unterstützen, wie es hat C ++ (bis zum C ++ 11 Standard). Zweitens die Sprachen, die behandeln erstklassige Funktionen (Dylan, Haskell, JavaScript, Lispeln, Ml, Perl, Python, Rubin, Planen) haben im Allgemeinen eine anonyme Funktionsunterstützung, damit Funktionen so einfach definiert und herumgegeben werden können wie andere Datentypen.

Liste der Sprachen

Sprache	Die Unterstützung	Anmerkungen
Aktionen
Ada	N	Ausdrucksfunktionen sind Teil von ADA2012
Algol 68
Apl		Dyalog, NGN und Dzaima APL unterstützen voll und ganz sowohl DFNs als auch stillschweigende Funktionen. GNU APL hat eine eher begrenzte Unterstützung für DFNs.
Assemblersprachen	N
Verprügeln		Es wurde eine Bibliothek gemacht, um anonyme Funktionen in Bash zu unterstützen.[4]
C	N	Unterstützung ist in Klang und zusammen mit dem Llvm Compiler-RT lib. Für eine Makro -Implementierung wird GCC -Unterstützung gegeben, die die Möglichkeit der Verwendung ermöglicht. Weitere Informationen finden Sie weiter unten.
C#		[5]
C ++		Ab C ++ 11 Standard
Cfml		Ab Railo 4,,[6] Coldfusion 10[7]
Clojure		[8]
Cobol	N	Micro FocusDer nicht standardmäßig verwaltete COBOL-Dialekt unterstützt Lambdas, die als anonyme Delegierte/Methoden bezeichnet werden.[9]
Locken
D		[10]
Pfeil		[11]
Delphi		[12]
Dylan		[13]
Eiffel
Ulme		[14]
Elixier		[15]
Erlang		[16]
F#		[17]
Excel		Excel -Arbeitsblattfunktion, 2021 Beta -Release[18]
Faktor		"Zitate" unterstützen dies[19]
Forran	N
Frink		[20]
gehen		[21]
Gosu		[22]
Groovig		[23]
Haskell		[24]
Haxe		[25]
Java		Unterstützt in Java 8. Siehe das Java -Einschränkungen Abschnitt unten für Details.
JavaScript		[26]
Julia		[27]
Kotlin		[28]
Lispeln
Logtalk
Lua		[29]
MUMPS	N
Ahorn		[30]
Matlab		[31]
Maxima		[32]
Nim		[33]
Ocaml		[34]
Oktave		[35]
Objekt Pascal		Delphi, ein Dialekt des Objekts Pascal, unterstützt anonyme Funktionen (formal, Anonyme Methoden) Nativ seit Delphi 2009. Die Oxygen Das Objektpascal -Dialekt unterstützt sie ebenfalls.
Ziel c (Mac OS X 10.6+)		Genannt Blöcke; Zusätzlich zu Objective-C können Blöcke auch für C und C ++ verwendet werden, wenn sie auf der Apple-Plattform programmiert werden.
OpenScad		Funktionsunterstützung wurde mit Version 2021.01 eingeführt.[36]
Pascal	N
Perl		[37]
Php		Ab PHP 5.3.0 werden echte anonyme Funktionen unterstützt.[38] Früher wurden nur teilweise anonyme Funktionen unterstützt, was ähnlich wie die Implementierung von C#funktioniert hat.
Pl/i	N
Python		Python unterstützt anonyme Funktionen über die Lambda -Syntax,[39] Dies unterstützt nur Ausdrücke, keine Aussagen.
R
Schläger		[40]
Raku		[41]
Rexx	N
Rollenspiel	N
Rubin		Rubys anonyme Funktionen, geerbt von Smalltalk, werden genannt Blöcke.[42]
Rost		[43]
Scala		[44]
Planen
Smalltalk		Die anonymen Funktionen von SmallTalk werden genannt Blöcke.
Standard ml		[45]
Schnell		Die anonymen Funktionen von Swift werden als Schließungen bezeichnet.[46]
Typoskript		[47]
Tcl		[48]
Vala		[48]
Visual Basic .net v9		[49]
Visueller Prolog v 7.2		[50]
Wolfram Sprache		[51]

Beispiele

Zahlreiche Sprachen unterstützen anonyme Funktionen oder ähnliches.

Apl

Nur einige Dialekte unterstützen entweder als anonyme Funktionen als als dfnsim stillschweigenden Stil oder einer Kombination aus beiden.

  f←{⍵×⍵} ⍝ als DFN  f 1 2 3 1 4 9       g←⊢ × ⊢  ⍝ als stillschweigende 3-train (Gabel)  g 1 2 3 1 4 9  h←×⍨  ⍝ als abgeleitete stillschweigende Funktion  h 1 2 3 1 4 9 

C (nicht standardmäßige Erweiterung)

Die anonyme Funktion wird nicht durch die Standard -C -Programmiersprache unterstützt, sondern von einigen C -Dialekten, wie z. GCC^[52] und Klang.

GCC

GNU Compiler -Sammlung (GCC) unterstützt anonyme Funktionen, gemischt von durch verschachtelte Funktionen und Ausdrucksausdrücke. Es hat die Form:

( { return_type anonymous_functions_name (Parameter) { function_body } anonymous_functions_name; } ) 

Das folgende Beispiel funktioniert nur mit GCC. Wegen der Erweiterung von Makros, die l_body kann keine Kommas außerhalb von Klammern enthalten; GCC behandelt das Komma als Trennzeichen zwischen Makroargumenten. Das Argument l_ret_type kann entfernt werden, wenn __Art der__ ist verfügbar; Im Beispiel unten verwendet __Art der__ auf Array würde zurückkehren typtype *, was bei Bedarf für den tatsächlichen Wert derenferenziert werden kann.

#enthalten  // * Dies ist die Definition der anonymen Funktion */ #define lambda (l_ret_type, l_arguments, l_body) \   ({\    l_ret_type l_anonymous_functions_name l_arguments \    l_body \    & l_anonymous_functions_name; \    }) #define foreachinarray (fe_arrtype, fe_arr, fe_fn_body) \ {\   int i = 0; \   für (; i <sizeof (fe_arr)/sizeof (fe_arrtype); i ++) {fe_arr [i] = fe_fn_body (& fe_arr [i]); } \ } Typedef Struktur {   int a;   int b; } typtype; Leere ausdrucken(Const typtype * Array) {   int i;   zum ( i = 0; i < 3; ++ i )   printf(" %d %d\n", Array[i].a, Array[i].b);   printf("\n"); } int hauptsächlich(Leere) {   typtype Array[] = { {0,1}, {2,3}, {4,5} };   ausdrucken(Array);   / * Die anonyme Funktion wird als Funktion für die Foreach */angegeben   foreachinarray(typtype, Array,   Lambda (typtype, (Leere *Artikel),   {   int Temperatur = (*( typtype *) Artikel).a;   (*( typtype *) Artikel).a = (*( typtype *) Artikel).b;   (*( typtype *) Artikel).b = Temperatur;   Rückkehr (*( typtype *) Artikel);   }));   ausdrucken(Array);   Rückkehr 0; } 

Clang (c, c ++, objektiv-c, objektiv-c ++)

Klang Unterstützt anonyme Funktionen, genannt Blöcke,^[53] die die Form haben:

^return_type ( Parameter ) { function_body } 

Der Typ der obigen Blöcke ist return_type (^) (Parameter).

Mit dem oben genannten Blöcke Erweiterung und Grand Central Dispatch (libdispatch) Der Code könnte einfacher aussehen:

#enthalten  #enthalten  int hauptsächlich(Leere) {   Leere (^count_loop) ()) = ^{   zum (int i = 0; i < 100; i++)   printf("%d\n", i);   printf("Ah ah Ah\n");   }; / * Als Parameter an eine andere Funktion übergeben */   issatch_async(issatch_get_global_queue(ISSATCH_QUEUE_PRIORITY_DEFAULT, 0), count_loop); / * Direkt aufrufen */   count_loop();   Rückkehr 0; } 

Der Code mit Blöcken sollte mit kompiliert werden -fblocks und verbunden mit -lblocksruntime

C ++ (da C ++ 11)

C ++ 11 Unterstützt anonyme Funktionen, genannt Lambda -Ausdrücke,^[54] die die Form haben:

[Erfassung] (Parameter) -> return_type { function_body } 

Dies ist ein Beispiel für den Lambda -Ausdruck:

[] (int x, int y) { Rückkehr x + y; } 

C ++ 11 unterstützt auch Schließungen, hier namens Captures. Erfassungen werden zwischen quadratischen Klammern definiert [und ] in der Erklärung des Lambda -Ausdrucks. Mit dem Mechanismus können diese Variablen durch Wert oder Referenz erfasst werden. Die folgende Tabelle zeigt dies:

[]  // Keine Erfassungen, die Lambda ist implizit in einen Funktionszeiger konvertierbar. [x, &y]  // x wird von Wert erfasst und y durch Bezugnahme erfasst. [&]  // Jede externe Variable wird bei Verwendung implizit durch Referenz erfasst [=]  // Jede externe Variable wird bei Verwendung implizit nach Wert erfasst. [&, x]  // x wird von Wert erfasst. Andere Variablen werden durch Referenz erfasst. [=, &z]  // z wird durch Bezugnahme erfasst. Andere Variablen werden von Wert erfasst. 

Variablen, die nach Wert erfasst werden, sind standardmäßig konstant. Hinzufügen veränderlich Nach der Parameterliste macht sie nicht konstant.

C ++ 14 und neuere Versionen unterstützen die Init-Capture, zum Beispiel:

std::Unique_ptr<int> ptr = std::make_unique<int>(42); [ptr] { / * ... */ }; // Die Kopiezuordnung wird für einen eindeutigen Zeiger gelöscht [ptr = std::Bewegung(ptr)] { / * ... */ }; // OK Auto Zähler = [i = 0] () veränderlich { Rückkehr i++; }; // Mutable ist erforderlich, um 'i' zu ändern Zähler(); // 0 Zähler(); // 1 Zähler(); // 2 

Die folgenden zwei Beispiele zeigen die Verwendung eines Lambda -Ausdrucks:

std::Vektor<int> SONDER_LIST{ 1, 2, 3, 4, 5 }; int gesamt = 0; std::für jeden(Start(SONDER_LIST), Ende(SONDER_LIST),    [&gesamt] (int x) {	gesamt += x; });  // Beachten Sie, dass std :: sammeln würde hier eine viel bessere Alternative ... 

Dies berechnet die Summe aller Elemente in der Liste. Die Variable gesamt wird als Teil der Schließung der Lambda -Funktion gespeichert. Da es sich um eine Verweise auf die Stapelvariable handelt gesamt, es kann seinen Wert ändern.

std::Vektor<int> SONDER_LIST{ 1, 2, 3, 4, 5 }; int gesamt = 0; int Wert = 5; std::für jeden(Start(SONDER_LIST), Ende(SONDER_LIST),    [&gesamt, Wert, Dies] (int x) { gesamt += x * Wert * Dies->SONDER_FUNC(); }); 

Dies wird verursachen gesamt als Referenz gespeichert werden, aber Wert wird als Kopie gespeichert.

The capture of Dies ist speziell. Es kann nur durch Wert und nicht durch Bezugnahme erfasst werden. Jedoch in C ++ 17Das aktuelle Objekt kann durch Wert erfasst werden (bezeichnet durch *Dies) oder können durch Referenz erfasst werden (gekennzeichnet durch Dies). Dies kann nur erfasst werden, wenn die am nächsten liegende Funktion eine nicht statische Elementfunktion ist. Das Lambda hat den gleichen Zugang wie das Mitglied, das es in Bezug auf geschützte/private Mitglieder erstellt hat.

Wenn Dies wird entweder explizit oder implizit erfasst, dann wird auch der Umfang der beigefügten Klassenmitglieder getestet. Zugriff auf Mitglieder von Dies braucht keinen expliziten Gebrauch von this-> Syntax.

Die spezifische interne Implementierung kann variieren, aber die Erwartung ist, dass eine Lambda -Funktion, die alles durch Bezugnahme erfasst, den tatsächlichen Stapelzeiger der Funktion speichert, in dem sie erstellt wird, und nicht einzelne Verweise auf Stapelvariablen. Da die meisten Lambda -Funktionen klein und lokal im Bereich sind, sind sie wahrscheinlich Kandidaten für Einbindungund benötigen daher keinen zusätzlichen Speicher für Referenzen.

Wenn nach dem innersten Blockbereich seiner Schöpfung ein Verschlussobjekt, das Verweise auf lokale Variablen enthält, aufgerufen wird, ist das Verhalten nicht definiert.

Lambda-Funktionen sind Funktionsobjekte eines implementierungsabhängigen Typs. Der Name dieses Typs ist nur dem Compiler verfügbar. Wenn der Benutzer eine Lambda -Funktion als Parameter übernehmen möchte, muss der Parametertyp ein Vorlagentyp sein, oder er muss a erstellen STD :: Funktion oder ein ähnliches Objekt, um den Lambda -Wert zu erfassen. Die Verwendung der Verwendung der Auto Schlüsselwort kann helfen, die Lambda -Funktion zu speichern.

Auto my_lambda_func = [&] (int x) { /*...*/ }; Auto my_onheap_lambda_func = Neu Auto[=] (int x) { /*...*/ }); 

Hier ist ein Beispiel für die Speicherung anonymer Funktionen in Variablen, Vektoren und Arrays; und sie als Parameter übergeben:

#enthalten  #enthalten  #enthalten  doppelt bewerten(std::Funktion<doppelt(doppelt)> f, doppelt x = 2.0) {   Rückkehr f(x); } int hauptsächlich() {   std::Funktion<doppelt(doppelt)> f0 = [] (doppelt x) { Rückkehr 1; };   Auto F1 = [] (doppelt x) { Rückkehr x; };   deklart(f0) Fa[3] = {f0, F1, [] (doppelt x) { Rückkehr x * x; }};   std::Vektor<deklart(f0)> fv = {f0, F1};   fv.push_back([] (doppelt x) { Rückkehr x * x; });   zum (size_t i = 0; i < fv.Größe(); i++) {   std::Cout << fv[i] (2.0) << std::Endl;   }   zum (size_t i = 0; i < 3; i++) {   std::Cout << Fa[i] (2.0) << std::Endl;   }   zum (Auto& f : fv) {   std::Cout << f(2.0) << std::Endl;   }   zum (Auto& f : Fa) {   std::Cout << f(2.0) << std::Endl;   }   std::Cout << bewerten(f0) << std::Endl;   std::Cout << bewerten(F1) << std::Endl;   std::Cout << bewerten([] (doppelt x) { Rückkehr x * x; }) << std::Endl; } 

Ein Lambda -Ausdruck mit einer leeren Erfassungsspezifikation ([]) kann implizit in einen Funktionszeiger mit dem gleichen Typ wie der Lambda umgewandelt werden. Das ist also legal:

Auto a_lambda_func = [] (int x) { /*...*/ }; Leere (* func_ptr) (int) = a_lambda_func; func_ptr(4); // ruft die Lambda an. 

Ab C ++ 23Ein Lambda -Ausdruck kann durch explizit rekursiv sein Dies als erster Parameter:

Auto Fibonacci = [] (Dies Auto selbst, int n) { Rückkehr n <= 1 ? n : selbst(n - 1) + selbst(n - 2); }; Fibonacci(7); // 13 

Das Schub Die Bibliothek bietet auch eine eigene Syntax für Lambda -Funktionen mit der folgenden Syntax:^[55]

für jeden(a.Start(),, a.Ende(),, std::Cout << _1 << '' '); 

C#

Im C#Die Unterstützung für anonyme Funktionen hat die verschiedenen Versionen des Sprachkompilers vertieft. The Language V3.0, veröffentlicht im November 2007 mit .NET Framework v3.5, hat die volle Unterstützung anonymer Funktionen. C# nennt sie Lambda -Ausdrücke, folgt der Originalversion der anonymen Funktionen, die Lambda -Kalkül.^[56]

// Das erste int ist der x 'Typ' // Der zweite Int ist der Rückgabetyp // <siehe href = "http://msdn.microsoft.com/en-us/library/bb549151.aspx" /> Func foo = x => x * x; Console.WriteLine(foo(7)); 

Obwohl die Funktion anonym ist, kann sie nicht einer implizit typisierten Variablen zugeordnet werden, da die Lambda -Syntax verwendet werden kann, um eine anonyme Funktion oder einen Ausdrucksbaum zu bezeichnen, und die Auswahl kann nicht automatisch vom Compiler entschieden werden. Z. B. funktioniert nicht:

// wird nicht kompilieren! var Foo = (int x) => x * x; 

Ein Lambda -Ausdruck kann jedoch teilnehmen Geben Sie Inferenz ein und kann als als verwendet werden Methodenargument, z.B. Verwenden von anonymen Funktionen mit der verfügbaren Kartenfähigkeit mit System.Collectionss.generic.list (in dem Konvertieren alle() Methode):

// Initialisieren Sie die Liste: var Werte = Neu Aufführen<int> () { 7, 13, 4, 9, 3 }; // Die anonyme Funktion über alle Elemente in der Liste zuordnen, geben Sie die neue Liste zurück var Foo = Werte.Konvertieren alle(d => d * d) ;  // Das Ergebnis der FOO -Variablen ist vom Typ System.collections.generic.list <int32> 

Frühere Versionen von C# hatten eine begrenzte Unterstützung für anonyme Funktionen. C# v1.0, eingeführt im Februar 2002 mit dem .NET Framework v1.0, lieferte eine teilweise anonyme Funktionsunterstützung durch die Verwendung von Delegierte. Dieses Konstrukt ähnelt etwas PHP -Delegierten. In C# 1.0 sind Delegierte wie Funktionszeiger, die sich auf eine explizit benannte Methode innerhalb einer Klasse beziehen. (Im Gegensatz zu PHP ist der Name zum Zeitpunkt der Verwendung des Delegiertens nicht benötigt Blöcke, die in einem Delegiertenaufruf ausgeführt werden können. C# 3.0 unterstützt weiterhin diese Konstrukte, unterstützt aber auch das Lambda -Expressionskonstrukt.

Dieses Beispiel wird in C# 3.0 kompilieren und zeigt die drei Formen:

  Öffentlichkeit Klasse Testfahrer  {  delegieren int Quadrat(int d);  statisch int Quadrat(int d)  {  Rückkehr d * d;  }    statisch Leere Hauptsächlich(Saite[] Args)  {  // C# 1.0: Die ursprüngliche Delegate -Syntax benötigt   // Initialisierung mit einer benannten Methode.  Quadrat A = Neu Quadrat(Quadrat);  System.Konsole.Schreiben(A(3));    // C# 2.0: Ein Delegierter kann mit initialisiert werden  // Inline -Code, als "anonyme Methode" bezeichnet. Dies  // Methode nimmt einen INT als Eingabeparameter ein.  Quadrat B = delegieren(int d) { Rückkehr d * d; };  System.Konsole.Schreiben(B(5));    // C# 3.0. Ein Delegierter kann mit initialisiert werden  // Ein Lambda -Ausdruck. Die Lambda nimmt ein int und gibt einen int zurück.   // Die Art des X wird vom Compiler abgeleitet.  Quadrat C = x => x * x;  System.Konsole.Schreiben(C(7));    // C# 3.0. Ein Delegierter, der einen Eingang akzeptiert und  // Gibt eine Ausgabe zurück, die auch mit dem Func <> -Typ deklariert werden kann.  System.Func<int,int> D = x => x * x;  System.Konsole.Schreiben(D(9));  }   } 

Im Fall der C# 2.0 -Version übernimmt der C# Compiler den Codeblock der anonymen Funktion und erstellt eine statische private Funktion. Innen erhält die Funktion natürlich einen generierten Namen. Dieser generierte Name basiert auf dem Namen der Methode, bei der der Delegierte deklariert wird. Der Name wird jedoch nur mit Verwendung des Anwendungscodes ausgesetzt Betrachtung.

Bei der C# 3.0 -Version gilt der gleiche Mechanismus.

ColdFusion Markup Sprache (CFML)

Verwendung der Funktion Stichwort:

fn = Funktion() {  // Aussagen }; 

Oder verwenden Sie eine Pfeilfunktion:

fn = () => {  // Aussagen }; fn = () => SingleExpression // SingleExpression wird implizit zurückgegeben. Die Zahnspangen oder das Keyword zurückgeben, sind nicht erforderlich fn = Singleparam => { // Wenn die Pfeilfunktion nur einen Parameter hat, sind keine Klammern erforderlich  // Aussagen } fn = (x, y) => { // Wenn die Pfeilfunktion null oder mehrere Parameter hat, muss man Klammern verwenden  // Aussagen } 

CFML unterstützt alle Aussagen in der Definition der Funktion, nicht nur Ausdrücke.

CFML unterstützt rekursive anonyme Funktionen:

Fakultät = Funktion(n) {  Rückkehr n > 1 ? n * Fakultät(n-1) : 1; }; 

Anonyme Funktionen von CFML implementieren Schließungen.

D

D verwendet Inline Delegierte um anonyme Funktionen zu implementieren. Die vollständige Syntax für einen Inline -Delegierten ist

return_type delegieren(Argumente) {/*Karosserie*/} 

Wenn eindeutig, der Rückgabetyp und das Schlüsselwort delegieren kann ausgelassen werden.

(x) {Rückkehr x*x;} delegieren (x) {Rückkehr x*x;} // Wenn mehr Ausführlichkeit benötigt wird (int x) {Rückkehr x*x;} // Wenn der Parametertyp nicht abgeleitet werden kann delegieren (int x) {Rückkehr x*x;} // dito delegieren doppelt(int x) {Rückkehr x*x;} // Wenn der Rückgabetyp manuell erzwungen werden muss 

Seit Version 2.0, D Zertifiziert Schließungen auf dem Haufen, es sei denn, der Compiler kann beweisen, dass er unnötig ist. das Umfang Schlüsselwort kann zum Erzwingen der Stapelzuweisung verwendet werden. Seit Version 2.058 ist es möglich, eine Kurznotation zu verwenden:

x => x*x; (int x) => x*x; (x,y) => x*y; (int x, int y) => x*y; 

Eine anonyme Funktion kann einer Variablen zugeordnet und wie folgt verwendet werden:

Auto sqr = (doppelt x) {Rückkehr x*x;}; doppelt y = sqr(4); 

Pfeil

Pfeil Unterstützt anonyme Funktionen.^[11]

var sqr = (x) => x * x; drucken(sqr(5)); 

oder

drucken((((x) => x * x) (5)); 

Delphi

Delphi Einführte anonyme Funktionen in Version 2009.

Programm Demo; Typ  TSimpleProcedure = Hinweis zu Verfahren;  TSimplefunktion = Hinweis zu Funktion(Const x: Saite): Ganze Zahl; var  x1: TSimpleProcedure;  y1: TSimplefunktion; Start  x1 : = Verfahren  Start  Writeln('Hallo Welt');  Ende;  x1;  // Einbeziehen Sie eine anonyme Methode, die gerade definiert ist  y1 : = Funktion(Const x: Saite): Ganze Zahl  Start  Ergebnis : = Länge(x);  Ende;  Writeln(y1('Bar'));  Ende. 

Pascalabc.net

Pascalabc.net Unterstützt anonyme Funktionen mithilfe der Lambda -Syntax

Start  var n : = 10000000;  var pp : = Bereich(1,n)  .Auswählen(x->Rec(Zufällig(),Zufällig()))  .Wo(p->sqr(p.Gegenstand 1)+sqr(p.Punkt2)<1)  .Zählen/n*4;  Drucken(pp); Ende. 

Elixier

Elixier verwendet die Schließung fn für anonyme Funktionen.^[15]

Summe = fn(a, b) -> a + b Ende Summe.(4, 3) #=> 7 Quadrat = fn(x) -> x * x Ende Auflauf.Karte [1, 2, 3, 4], Quadrat #=> [1, 4, 9, 16] 

Erlang

Erlang Verwendet eine Syntax für anonyme Funktionen, die denen genannter Funktionen ähneln.^[16]

% Anonyme Funktion an die quadratische Variable gebunden Quadrat = Spaß(X) -> X * X Ende. % Genannte Funktion mit der gleichen Funktionalität Quadrat(X) -> X * X. 

gehen

gehen Unterstützt anonyme Funktionen.^[21]

Foo : = Func(x int) int { 	Rückkehr x * x } fmt.Println(Foo(10)) 

Haskell

Haskell Verwendet eine kurze Syntax für anonyme Funktionen (Lambda -Ausdrücke). Der Backslash soll λ ähneln.

\x -> x * x 

Lambda-Ausdrücke sind vollständig in die Typ-Inferenz-Engine integriert und unterstützen alle Syntax und Merkmale der "gewöhnlichen" Funktionen (mit Ausnahme der Verwendung mehrerer Definitionen für die Musteranpassung, da die Argumentliste nur einmal angegeben ist).

Karte (\x -> x * x) [1..5] - Rückkehr [1, 4, 9, 16, 25] 

Das Folgende ist alle gleichwertig:

f x y = x + y f x = \y -> x + y f = \x y -> x + y 

Haxe

Im HaxeAnonyme Funktionen werden als Lambda bezeichnet und verwenden die Syntax Funktionsausdruck (Argumentliste); .

var f = Funktion(x) Rückkehr x*x; f(8); // 64 (Funktion(x,y) Rückkehr x+y) (5,6); // 11 

Java

Java Unterstützt anonyme Funktionen, benannt Lambda -Ausdrücke, beginnen mit JDK 8.^[57]

Ein Lambda -Ausdruck besteht aus einer von Kommas getrennten Liste der formalen Parameter, die in Klammern, einem Pfeil -Token, eingeschlossen sind (->) und ein Körper. Datentypen der Parameter können immer weggelassen werden, ebenso wie die Klammern, wenn nur ein Parameter vorhanden ist. Der Körper kann aus einer Anweisung oder einem Anweisungsblock bestehen.^[58]

// ohne Parameter () -> System.aus.println("Hallo Welt.") // mit einem Parameter (dieses Beispiel ist eine Identitätsfunktion). a -> a // mit einem Ausdruck (a, b) -> a + b // mit expliziten Typinformationen (lang Ich würde, Saite Name) -> "Ich würde: " + Ich würde + ", Name:" + Name // mit einem Codeblock (a, b) -> { Rückkehr a + b; } // mit mehreren Aussagen im Lambda -Körper. Es braucht einen Codeblock. // Dieses Beispiel enthält auch zwei verschachtelte Lambda -Ausdrücke (das erste ist ebenfalls eine Schließung). (Ich würde, Standardprice) -> {  Optional<Produkt> Produkt = Produktliste.Strom().Filter(p -> p.Getid() == Ich würde).Findfirst();  Rückkehr Produkt.Karte(p -> p.Getprice()).Orelse(Standardprice); } 

Lambda -Ausdrücke werden in "funktionelle Schnittstellen" konvertiert (definiert als Schnittstellen, die nur eine abstrakte Methode enthalten, zusätzlich zu einer oder mehreren Standard- oder statischen Methoden).^[58] Wie im folgenden Beispiel:

Öffentlichkeit Klasse Taschenrechner {  Schnittstelle Ganzzahl {  int Betrieb(int a, int b);  Ursprünglich Ganzzahl Tauschen() {  Rückkehr (a, b) -> Betrieb(b, a);  }  }  Privatgelände statisch int anwenden(int a, int b, Ganzzahl op) {  Rückkehr op.Betrieb(a, b);  }  Öffentlichkeit statisch Leere hauptsächlich(Saite... Args) {  Ganzzahl Zusatz = (a, b) -> a + b;  Ganzzahl Subtraktion = (a, b) -> a - b;  System.aus.println("40 + 2 =" + anwenden(40, 2, Zusatz));  System.aus.println("20 - 10 =" + anwenden(20, 10, Subtraktion));  System.aus.println("10 - 20 =" + anwenden(20, 10, Subtraktion.Tauschen()));      } } 

In diesem Beispiel wurde eine funktionale Schnittstelle aufgerufen Ganzzahl wird deklariert. Lambda -Ausdrücke, die implementiert werden Ganzzahl werden an die übergeben anwenden() Methode auszuführen. Standardmethoden wie Tauschen Definieren Sie Methoden zu Funktionen.

Java 8 führte einen weiteren Mechanismus namens Method Reference ein (die :: Bediener) zum Erstellen einer Lambda für eine vorhandene Methode. Eine Methodenreferenz gibt nicht die Anzahl oder Argumentypen an, da diese aus der abstrakten Methode der funktionalen Schnittstelle extrahiert werden.

IntBinaryoperator Summe = Ganze Zahl::Summe; 

Im obigen Beispiel der funktionalen Schnittstelle IntBinaryoperator deklariert eine abstrakte Methode int ApplaTaint (int, int)Daher sucht der Compiler nach einer Methode int sum (int, int) in der Klasse Java.lang.Inebier.

Java -Einschränkungen

Java 8 Lambdas haben die folgenden Einschränkungen:

• Lambdas können überprüfte Ausnahmen werfen, aber solche Lambdas funktionieren nicht mit den von der Sammlungs -API verwendeten Schnittstellen.
• Variablen, die im SCOPE sind, bei dem das Lambda deklariert wird, dürfen nur innerhalb des Lambda zugegriffen werden, wenn sie effektiv endgültig sind, d. H. Wenn die Variable innerhalb oder außerhalb des Lambda-Bereichs nicht mutiert ist.

JavaScript

JavaScript/ECMaskript Unterstützt anonyme Funktionen.

Alarm((Funktion(x) {  Rückkehr x * x; }) (10)); 

Es6 Unterstützt "Pfeilfunktion" -Syntax, wobei a => Das Symbol trennt die Parameterliste der anonymen Funktion vom Körper:

Alarm((x => x * x) (10)); 

Dieses Konstrukt wird oft in verwendet Lesezeichen. Zum Beispiel um den Titel des aktuellen Dokuments zu ändern (sich in seinem Fenster sichtbar Titelleiste) zu seinem URLDas folgende Lesezeichen scheint zu funktionieren.

JavaScript:dokumentieren.Titel=Lage.href; 

Da die Zuweisungsanweisung jedoch einen Wert (die URL selbst) zurückgibt, erstellen viele Browser tatsächlich eine neue Seite, um diesen Wert anzuzeigen.

Stattdessen kann eine anonyme Funktion, die keinen Wert zurückgibt, verwendet werden:

JavaScript:(Funktion() {dokumentieren.Titel=Lage.href;}) (); 

Die Funktionserklärung im ersten (äußeren) Parenthäenpaar deklariert eine anonyme Funktion, die dann bei Verwendung mit dem letzten Paar von Klammern ausgeführt wird. Dies entspricht fast der folgenden, was die Umgebung mit f Im Gegensatz zu einer anonymen Funktion.

JavaScript:var f = Funktion() {dokumentieren.Titel=Lage.href;}; f(); 

Verwenden Leere() Um neue Seiten für willkürliche anonyme Funktionen zu vermeiden:

JavaScript:Leere(Funktion() {Rückkehr dokumentieren.Titel=Lage.href;} ()); 

oder nur:

JavaScript:Leere(dokumentieren.Titel=Lage.href); 

JavaScript verfügt über syntaktische Feinheiten für die Semantik der Definition, Aufforderung und Bewertung anonymer Funktionen. Diese unterschwelligen Nuancen sind eine direkte Folge der Bewertung von Klammern. Die folgenden Konstrukte, die genannt werden Sofortiger Funktionsausdruck Illustrieren dies:

(Funktion() { ... } ()) 

und

(Funktion() { ... }) ()) 

Repräsentation "function () {...}" durch fDie Form der Konstrukte ist ein Klammern innerhalb eines Klammerns (f()) und ein Klammern, das auf einen Klammern angewendet wird (f)().

Beachten Sie die allgemeine syntaktische Ambiguität eines Klammerns, in Klammern, die eine Funktion und die Klammern um die formalen Parameter in einer Funktionsdefinition um die formalen Parameter umging. Insbesondere definiert JavaScript a , (Komma) Operator im Kontext eines Klammerns. Es ist kein Zufall, dass die syntaktischen Formen für einen Ausdruck und die Argumente einer Funktion übereinstimmen (ignorieren die formale Funktionssyntax der Funktion)! Wenn f wird nicht in den oben genannten Konstrukten identifiziert, sie werden (()) und () ()). Der erste bietet keinen syntaktischen Hinweis auf eine Resident -Funktion, aber das zweite muss die erste Klammung als Funktion als legales JavaScript bewerten. (Beiseite: Zum Beispiel die ()Es könnte sein ([], {}, 42, "ABC", function () {}), solange der Ausdruck eine Funktion bewertet.)

Außerdem ist eine Funktion eine Objektinstanz (ebenfalls Objekte sind Funktionsinstanzen) und die Objektliterale Notationsklammern. {} Für versperrte Code werden bei der Definition einer Funktion auf diese Weise verwendet (im Gegensatz zur Verwendung neue Funktion(...)). In einem sehr breiten nicht rigorosen Sinne (insbesondere weil globale Bindungen beeinträchtigt sind), eine willkürliche Folge von versperrten JavaScript-Aussagen, {Sachen}, kann als a angesehen werden Fixpunkt von

(Funktion() {(( Funktion() {(( ... {(( Funktion() {Sachen} ()) )} ... )} () )} () ) 

Korrekter, aber mit Vorbehalte,

( Funktion() {Sachen} ()) ) ~ =  A_fixed_point_of(  Funktion() { Rückkehr Funktion() { Rückkehr ... { Rückkehr Funktion() {Sachen} ()) } ... } ()) } ())  ) 

Beachten Sie die Auswirkungen der anonymen Funktion in den folgenden JavaScript -Fragmenten:

• function () {...} () ohne umgebend ()'S ist im Allgemeinen nicht legal
• (f = function () {...}) nicht "vergisst" f weltweit anders (Funktion f () {...})

Leistung Metriken um die zu analysieren Platz und Zeit Komplexitäten von Funktionsaufrufen, Anrufstapel usw. in einem JavaScript Dolmetscher Motor Implementieren Sie einfach mit diesen letzten anonymen Funktionskonstrukten. Aus den Implikationen der Ergebnisse ist es möglich, einige rekursive und iterative Implementierungsdetails einer Motor zu leiten, insbesondere die Details Schwanzrezision.

Julia

Im Julia Anonyme Funktionen werden mit der Syntax definiert (Argumente)-> (Ausdruck)Anwesend

Julia> f = x -> x*x; f(8) 64 Julia> ((x,y)->x+y) (5,6) 11 

Lispeln

Lispeln und Planen Unterstützen Sie anonyme Funktionen mithilfe des "Lambda" -Konstrukts, das ein Hinweis auf Lambda -Kalkül. Clojure Unterstützt anonyme Funktionen mit der Sonderform "FN" und #() Readersyntax.

(Lambda (arg) (* arg arg)) 

Common Lisp

Common Lisp hat das Konzept der Lambda -Ausdrücke. Ein Lambda -Ausdruck wird als Liste mit dem Symbol "Lambda" als erstes Element geschrieben. Die Liste enthält dann die Argumentliste, Dokumentation oder Deklarationen und eine Funktionsbehörde. Lambda -Ausdrücke können in Lambda -Formularen und mit der Special Operator "Funktion" verwendet werden.

(Funktion (Lambda (arg) (etwas tun arg))) 

"Funktion" kann als #'abgekürzt werden. Auch Makro Lambda existiert, was sich in eine Funktionsform ausdehnt:

; Mit scharfen Zitat #'(Lambda (arg) (etwas tun arg)) ; Verwenden des Lambda -Makros: (Lambda (arg) (etwas tun arg)) 

Eine typische Verwendung anonymer Funktionen bei gemeinsamer LISP besteht darin, sie an Funktionen höherer Ordnung zu übergeben wie MAPCAR, was eine Funktion auf jedes Element einer Liste anwendet und eine Liste der Ergebnisse zurückgibt.

(MAPCAR #'(Lambda (x) (* x x))  '(1 2 3 4)) ; -> (1 4 9 16) 

Das Lambda -Form in gemeinsamer LiSP erlaubt a Lambda -Ausdruck in einem Funktionsaufruf geschrieben werden:

((Lambda (x y)  (+ (sqrt x) (sqrt y)))  10.0  12.0) 

Anonyme Funktionen in gemeinsamen LISP können später auch globale Namen erhalten:

(setf (Symbolfunktion 'sqr)  (Lambda (x) (* x x))) ; Dadurch können wir es mit dem Namen SQR anrufen: (sqr 10.0) 

Planen

Schema benannte Funktionen ist einfach syntethischer Zucker Für anonyme Funktionen, die an Namen gebunden sind:

(definieren (Somename arg)  (etwas tun arg)) 

erweitert (und ist gleichwertig) zu

(definieren Somename  (Lambda (arg)  (etwas tun arg))) 

Clojure

Clojure Unterstützt anonyme Funktionen in der speziellen Form "FN":

(fn [x] (+ x 3)) 

Es gibt auch eine Lesersyntax, um eine Lambda zu definieren:

#(+ % %2%3) ; Definiert eine anonyme Funktion, die drei Argumente aufnimmt und zusammenfasst. 

Wie Schema sind Clojures "benannte Funktionen" einfach syntaktischen Zucker für Lambdas, die an Namen gebunden sind:

(Defn Func [arg] (+ 3 arg)) 

erweitert::

(def Func (fn [arg] (+ 3 arg))) 

Lua

Im Lua (Ähnlich wie im Schema) Alle Funktionen sind anonym. EIN benannte Funktion In Lua befindet sich einfach eine Variable, die einen Verweis auf ein Funktionsobjekt hält.^[59]

Somit in Lua

Funktion Foo(x) Rückkehr 2*x Ende 

ist nur syntaktischer Zucker für

Foo = Funktion(x) Rückkehr 2*x Ende 

Ein Beispiel für die Verwendung anonymer Funktionen für die Sortierung umgekehrter Ordnung:

table.sort(Netzwerk, Funktion(a,b)  Rückkehr a.Name > b.Name Ende) 

Wolfram Sprache, Mathematica

Das Wolfram Sprache ist die Programmiersprache von Mathematica. Anonyme Funktionen sind wichtig für die Programmierung der letzteren. Es gibt verschiedene Möglichkeiten, sie zu erstellen. Im Folgenden finden Sie einige anonyme Funktionen, die eine Zahl erhöhen. Das erste ist das häufigste. #1 bezieht sich auf das erste Argument und & markiert das Ende der anonymen Funktion.

  #1+1&   Funktion[x,x+1]   x \[Funktion] x+1 

Also zum Beispiel:

  f: = #1^2&;f[8]   64   #1+#2&[5,6]   11 

Außerdem verfügt Mathematica über ein zusätzliches Konstrukt, um rekursive anonyme Funktionen zu erzielen. Das Symbol '#0' bezieht sich auf die gesamte Funktion. Die folgende Funktion berechnet die Fakultät seiner Eingabe:

  Wenn[#1 == 1, 1, #1 * #0[#1-1]]& 

Zum Beispiel wäre 6 Fakultäten:

  Wenn[#1 == 1, 1, #1 * #0[#1-1]]&[6] 720 

Matlab, Oktave

Anonyme Funktionen in Matlab oder Oktave werden unter Verwendung der Syntax definiert @(Argument-Liste) Ausdruck. Alle Variablen, die in der Argumentliste nicht gefunden werden, werden aus dem umschließenden Bereich geerbt und von Wert erfasst.

>> f = @(x)x*x; f(8) Ans =  64 >> (@((x,y)x+y) (5,6) % Funktioniert nur in Oktave Ans =  11 

Maxima

Im Maxima Anonyme Funktionen werden mit der Syntax definiert Lambda (Argumentliste, Ausdruck)Anwesend

 F: lambda ([x], x*x); f (8); 64  lambda ([x, y], x+y) (5,6); 11 

Ml

Die verschiedenen Dialekte von Ml Unterstützen Sie anonyme Funktionen.

Ocaml

Anonyme Funktionen in OCAML sind Funktionen ohne deklarierter Name. Hier ist ein Beispiel für eine anonyme Funktion, die ihre Eingabe um zwei multipliziert:

Spaß x -> x*2 

Im Beispiel ist Spaß ein Schlüsselwort, das angibt, dass die Funktion eine anonyme Funktion ist. Wir geben in einem Argument x und -> das Argument vom Körper ab.^[60]

F#

F# Unterstützt anonyme Funktionen,^[17] folgendermaßen:

(Spaß x -> x * x) 20 // 400 

Standard ml

Standard ml Unterstützt anonyme Funktionen wie folgt:

fn arg => arg * arg

Nim

Nim Unterstützt anonyme Funktionen mit mehreren Expressionen mit mehreren Expressionen. ^[33]

var Anon = Proc (var1, var2: int): int = var1 + var2 behaupten Anon(1, 2) == 3 

Multi-Line-Beispiel:

var Anon = Func (x: int): bool =  wenn x > 0:  Ergebnis = Stimmt  anders:   Ergebnis = FALSCH behaupten Anon(9) 

Anonyme Funktionen können als Eingabeparameter anderer Funktionen übergeben werden:

var Städte = @["Frankfurt", "Tokio", "New York"] Städte.Sortieren(  Proc (x, y: Saite): int = CMP(x.Len, y.Len) ) 

Eine anonyme Funktion ist im Grunde eine Funktion ohne Namen.

Perl

Perl 5

Perl 5 Unterstützt anonyme Funktionen,^[37] folgendermaßen:

(Sub { drucken "Ich wurde \ n genannt" })->();  # 1. vollständig anonym, als erstellt bezeichnet mein $ Squarer = Sub { mein $ x = Wechsel; $ x * $ x }; # 2. einer Variablen zugewiesen Sub Curry {  mein ($ sub, @Args) = @_;  Rückkehr Sub { $ sub->(@Args, @_) };  # 3. als Rückgabewert einer anderen Funktion } # Beispiel für das Currying in der Perl -Programmierung Sub Summe { mein $ TOT = 0; $ TOT += $ _ zum @_; $ TOT } # Gibt die Summe seiner Argumente zurück mein $ Curry = Curry \ &Summe, 5, 7, 9; drucken $ Curry->(1,2,3), "\n";  # Drucke 27 (= 5 + 7 + 9 + 1 + 2 + 3) 

Andere Konstrukte nehmen nackte Blöcke Als Argumente, die eine ähnliche Funktion der Lambda-Funktionen eines Parameters erfüllen, aber nicht die gleiche Parameter-Passing-Konvention wie Funktionen haben-wird @_ nicht festgelegt.

mein @ -Squares = Karte { $ _ * $ _ } 1..10;  # Karte und Grep verwenden nicht das Schlüsselwort "Sub" mein @Square2 = Karte $ _ * $ _, 1..10;  # Zahnspangen für einen Ausdruck nicht benötigt mein @schlechtes Beispiel = Karte { drucken zum @_ } 1..10; # Werte nicht wie normale Perlfunktion übergeben 

Php

Vor 4.0.1, Php hatte keine anonyme Funktionsunterstützung.^[61]

PHP 4.0.1 bis 5.3

PHP 4.0.1 führte die vor create_function Dies war die erste anonyme Funktionsunterstützung. Dieser Funktionsaufruf macht eine neue zufällig benannte Funktion und gibt ihren Namen zurück (als Zeichenfolge)

$ foo = create_function('$ x', 'Return $ x*$ x;'); $ bar = create_function("\ $x", "Rückkehr \ $x*\ $x;"); Echo $ foo(10); 

Die Argumentliste und die Funktionsbehörde müssen in einzelnen Zitaten sein, oder die Dollar -Zeichen müssen entkommen. Ansonsten geht PHP davon aus, "$ x"bedeutet die Variable $ x und wird es in die Zeichenfolge ersetzen (trotz möglicherweise nicht existierender), anstatt zu gehen. "$ x"In der Zeichenfolge. Für Funktionen mit Zitaten oder Funktionen mit vielen Variablen kann es ziemlich mühsam werden, sicherzustellen, dass die beabsichtigte Funktionsorganisation das ist, was PHP interpretiert.

Jede Berufung von create_function macht eine neue Funktion, die für den Rest des Programms existiert und nicht sein kann Müll gesammeltVerwenden von Speicher im Programm irreversibel. Wenn dies verwendet wird, um anonyme Funktionen viele Male zu erstellen, z. B. in einer Schleife, kann dies zu Problemen wie dem Gedächtnisaufblähen führen.

PHP 5.3

PHP 5.3 fügte eine neue Klasse namens hinzu Schließung und magische Methode __aufrufen() Das macht eine Klasseninstanz eingeladen.^[62]

$ x = 3; $ func = Funktion($ z) { Rückkehr $ z * 2; }; Echo $ func($ x); // Drucke 6 

In diesem Beispiel, $ func ist eine Instanz von Schließung und Echo $ func ($ x) ist äquivalent zu Echo $ func-> __ aufrufen ($ x). PHP 5.3 ahmt anonyme Funktionen nach, aber es unterstützt keine echten anonymen Funktionen, da PHP-Funktionen immer noch keine erstklassigen Objekte sind.

PHP 5.3 unterstützt Verschlüsse, aber die Variablen müssen explizit als solche angegeben werden:

$ x = 3; $ func = Funktion() verwenden(&$ x) { $ x *= 2; }; $ func(); Echo $ x; // Drucke 6 

Die Variable $ x wird durch Referenz gebunden, damit die Aufruf von $ func Verändert es und die Änderungen sind außerhalb der Funktion sichtbar.

Php 7.4

Pfeilfunktionen wurden in PHP 7.4 eingeführt

$ x = 3; $ func = fn($ z) => $ z * 2; Echo $ func($ x); // Drucke 6 

Prologs Dialekte

Logtalk

Logtalk Verwendet die folgende Syntax für anonyme Prädikate (Lambda -Ausdrücke):

{Freevar1, Freevar2, ...}/[Lambdaparameter1, Lambdaparameter2, ...]>>Tor 

Ein einfaches Beispiel ohne kostenlose Variablen und Verwendung eines Listen -Mapping -Prädikats ist:

| ?- Meta::Karte([X,Y]>>(Y ist 2*X), [1,2,3], Ys).Ys = [2,4,6] Jawohl

Currying wird ebenfalls unterstützt. Das obige Beispiel kann geschrieben werden als:

| ?- Meta::Karte([X]>>[Y]>>(Y ist 2*X)), [1,2,3], Ys).Ys = [2,4,6] Jawohl

Visueller Prolog

Anonyme Funktionen (im Allgemeinen Anonymous Prädikate) wurden eingeführt in Visueller Prolog in Version 7.2.^[63] Anonyme Prädikate können Werte aus dem Kontext erfassen. Wenn es in einem Objektmitglied erstellt wird, kann es auch auf den Objektzustand zugreifen (durch Erfassung Dies).

Mkadder Gibt eine anonyme Funktion zurück, die das Argument erfasst hat X in der Schließung. Die zurückgegebene Funktion ist eine Funktion, die hinzugefügt wird X zu seinem Argument:

Klauseln  Mkadder(X) = { (Y) = X+Y }. 

Python

Python Unterstützt einfache anonyme Funktionen durch das Lambda -Form.^[39] Der ausführbare Körper des Lambda muss ein Ausdruck sein und kann keine Aussage sein, eine Einschränkung, die ihren Nutzen einschränkt. Der von der Lambda zurückgegebene Wert ist der Wert des enthaltenen Ausdrucks. Lambda -Formulare können überall überall verwendet werden, wo gewöhnliche Funktionen können. Diese Einschränkungen machen es jedoch zu einer sehr begrenzten Version einer normalen Funktion. Hier ist ein Beispiel:

>>> Foo = Lambda x: x * x >>> Foo(10) 100 

Im Allgemeinen fördert die Python Convention die Verwendung benannter Funktionen, die im gleichen Bereich definiert sind, wie man in anderen Sprachen normalerweise anonyme Funktionen verwenden kann. Dies ist akzeptabel, wenn lokal definierte Funktionen die volle Leistung von implementieren Schließungen und sind fast so effizient wie die Verwendung eines Lambda in Python. In diesem Beispiel kann die integrierte Leistungsfunktion gesagt werden Curry:

>>> def make_pow(n): ...   def fixe_exponent_pow(x): ...   Rückkehr POW(x, n) ...   Rückkehr fixe_exponent_pow ... >>> sqr = make_pow(2) >>> sqr(10) 100 >>> Jungtier = make_pow(3) >>> Jungtier(10) 1000 

R

In R werden die anonymen Funktionen mit der Syntax definiert Funktionsausdruck (Argumentliste) .

> f <- Funktion(x)x*x; f(8) [1] 64 > (Funktion(x,y)x+y) (5,6) [1] 11 

Raku

Im Raku, alle Blöcke (sogar diejenigen, die mit if usw. usw. verbunden sind, sind anonyme Funktionen. Ein Block, der nicht als als verwendet wird rvalue wird sofort ausgeführt.

1. vollständig anonym, als erstellt bezeichnet

   { sagen "Ich wurde angerufen" };

2. einer Variablen zugeordnet

   mein $ squarer1 = -> $ x { $ x * $ x }; # 2a. Spitze Block mein $ squarer2 = {{ $^x * $^x }; # 2b. Zweigil mein $ squarer3 = {{ mein $ x = Wechsel @_; $ x * $ x }; # 2c. Perl 5 Stil 

3. Currying

   Sub hinzufügen ($ m, $ n) { $ m + $ n }mein $ sieben   = hinzufügen(3, 4);mein $ add_one = &hinzufügen.Annahme(M => 1); meine $ acht = $ add_one($ sieben);

4. Was auch immer Code -Objekt

   mein $ w = * - 1; # ENGLEUGECODE -Objekt mein $ b = {{ $ _ - 1 }; # Gleiche Funktionalität, aber als Callable Block 

Rubin

Ruby unterstützt anonyme Funktionen mithilfe einer syntaktischen Struktur genannt Block. Es gibt zwei Datentypen für Blöcke in Ruby. Procs verhalten sich ähnlich wie Schließungen, wohingegen LambdaS verhalten sich analog zu einer anonymen Funktion.^[42] Bei einer Methode wird ein Block unter bestimmten Umständen in einen Proc umgewandelt.

IRB (Haupt): 001: 0> # Beispiel 1: IRB (Haupt): 002: 0* # Rein anonyme Funktionen mit Blöcken. IRB (Haupt): 003: 0* ex = [16.2, 24.1, 48.3, 32.4, 8.5] => [16,2, 24,1, 48,3, 32,4, 8,5] IRB (Haupt): 004: 0> ex.Sortieren nach { |x| x - x.to_i } # Sortieren Sie nach Bruchteil und ignorieren Sie einen ganzzahligen Teil. => [24.1, 16.2, 48,3, 32,4, 8,5] IRB (Haupt): 005: 0> # Beispiel 2: IRB (Haupt): 006: 0* # Erstklassige Funktionen als explizites Objekt von Proc - IRB (Haupt): 007: 0* ex = Proc.Neu { stellt "Hallo Welt!" } => #<Proc: 0x007ff4598705a0@(IRB): 7> IRB (Haupt): 008: 0> ex.Anruf Hallo Welt! => nil IRB (Haupt): 009: 0> # Beispiel 3: IRB (Haupt): 010: 0* # Funktion, die das Lambda -Funktionsobjekt mit Parametern zurückgibt IRB (Haupt): 011: 0* def is_multiple_of(n) IRB (Haupt): 012: 1>   Lambda{|x| x % n == 0} IRB (Haupt): 013: 1> Ende => nil IRB (Haupt): 014: 0> multiple_four = is_multiple_of(4) => #<Proc: 0x007ff458b45f88@(IRB): 12 (Lambda)> IRB (Haupt): 015: 0> multiple_four.Anruf(16) => wahr IRB (Haupt): 016: 0> multiple_four[15] => Falsch 

Rost

Im RostAnonyme Funktionen werden als Schließungen bezeichnet.^[64] Sie werden unter Verwendung der folgenden Syntax definiert:

| <Parameter-Name>: <Typ> | -> <Rückkehr-Typ> { <Karosserie> }; 

Zum Beispiel:

Lassen f = |x: i32| -> i32 { x * 2 }; 

Mit dem Typ -Inferenz kann der Compiler jedoch den Typ jedes Parameters und den Rückgabetyp schließen, sodass das obige Formular als:

Lassen f = |x| { x * 2 }; 

Mit Verschlüssen mit einem einzigen Ausdruck (d. H. Eines Körper mit einer Linie) können die lockigen Klammern weggelassen werden:

Lassen f = |x| x * 2; 

Schließungen ohne Eingabeparameter werden wie SO geschrieben:

Lassen f = || println!("Hallo Welt!"); 

Schließungen können als Eingabeparameter von Funktionen übergeben werden, die einen Funktionszeiger erwarten:

// eine Funktion, die einen Funktionszeiger als Argument nimmt und ihn mit aufruft // Der Wert `5`. fn anwenden(f: fn(i32) -> i32) -> i32 {   // kein Semikolon, um eine implizite Rendite anzuzeigen   f(5) } fn hauptsächlich() {   // die Schließung definieren   Lassen f = |x| x * 2;   println!("{}", anwenden(f));  // 10   println!("{}", f(5));  // 10 } 

Möglicherweise benötigt man jedoch komplexe Regeln, um zu beschreiben, wie Werte im Körper des Verschlusses erfasst werden. Sie werden mit dem implementiert Fn, Fnmut, und Fnonce Züge:^[65]

• Fn: Die Schließung erfasst durch Bezugnahme (Referenz (&T). Sie werden für Funktionen verwendet, die noch aufgerufen werden können, wenn sie nur Referenzzugriff haben (mit &) zu ihrer Umgebung.
• Fnmut: Der Verschluss erfasst durch veränderliche Referenz (&Köter). Sie werden für Funktionen verwendet, die aufgerufen werden können, wenn sie einen veränderlichen Referenzzugriff haben (mit & Mut) zu ihrer Umgebung.
• Fnonce: Die Schließung erfasst nach Wert (T). Sie werden für Funktionen verwendet, die nur einmal genannt werden.

Mit diesen Merkmalen fängt der Compiler Variablen auf die am wenigsten restriktive Weise erfasst.^[65] Sie helfen zu bestimmen, wie die Werte zwischen den Teilen umgehen, was weitgehend wichtig ist, da Rost einem lebenslangen Konstrukt folgt, um sicherzustellen, dass die Werte "geliehen" und auf vorhersehbare und explizite Weise bewegt werden.^[66]

Das Folgende zeigt, wie man einen Verschluss als Eingabeparameter mit dem übergeben kann Fn Merkmal:

// eine Funktion, die einen Wert vom Typ F annimmt (der definiert ist als // ein generischer Typ, der das `fn` -Merkmal implementiert, z. eine Schließung) // und ruft es mit dem Wert `5` an. fn apply_by_ref<F>(f: F) -> i32  wo F: Fn(i32) -> i32 {   f(5) } fn hauptsächlich() {   Lassen f = |x| {   println!("Ich habe den Wert erhalten: {}", x);   x * 2   };      // wendet die Funktion vor dem Drucken ihres Rückgabewerts an   println!("5 * 2 = {}", apply_by_ref(f)); } // ~~ Programmausgabe ~~ // Ich habe den Wert erhalten: 5 // 5 * 2 = 10 

Scala

Im ScalaAnonyme Funktionen verwenden die folgende Syntax:^[67]

(x: Int, y: Int) => x + y 

In bestimmten Kontexten, wie wenn eine anonyme Funktion ein Parameter ist, der an eine andere Funktion übergeben wird, kann der Compiler die Arten der Parameter der anonymen Funktion schließen und können in die Syntax weggelassen werden. In solchen Kontexten ist es auch möglich, eine Abkürzung für anonyme Funktionen mit dem Unterstrich zu verwenden, um unbenannte Parameter einzuführen.

val aufführen = Aufführen(1, 2, 3, 4) aufführen.Reduceleft( (x, y) => x + y )  // Hier kann der Compiler schließen, dass die Arten von x und y beide int sind.  // Daher benötigt es keine Typanmerkungen zu den Parametern der anonymen Funktion. aufführen.Reduceleft( _ + _ )    // Jeder Unterstrich steht für einen neuen unbenannten Parameter in der anonymen Funktion.  // Dies führt zu einem noch kürzeren Äquivalent zur obigen anonymen Funktion. 

Smalltalk

Im Smalltalk Anonyme Funktionen werden genannt Blöcke und sie werden angerufen (genannt), indem sie ihnen eine "Wert" -Meldung senden. Wenn mehrere Argumente übergeben werden sollen, muss ein "Wert: ... Wert:" Nachricht mit einer entsprechenden Anzahl von Wertargumenten verwendet werden.

Zum Beispiel in Gnu smalltalkAnwesend

st> f: =[:x|x*x]. f Wert: 8 . 64 st> [:x :y|x+y] Wert: 5 Wert: 6 . 11 

SmallTalk -Blöcke sind technisch gesehen Verschluss, sodass sie ihren definierenden Umfang überleben und sich immer noch auf die darin erklärten Variablen beziehen.

st> f : = [:a|[:n|a+n]] Wert: 100 . a Blockierung "Gibt den inneren Block zurück, der 100 hinzugefügt wird (in" gefangen genommen ".a"Variable) zu seinem Argument." st> f Wert: 1 . 101 st> f Wert: 2 . 102 

Schnell

Im SchnellAnonyme Funktionen werden als Schließungen bezeichnet.^[46] Die Syntax hat die folgende Form:

{ (Parameter) -> Rückkehr in   Aussage } 

Zum Beispiel:

{ (S1: Saite, S2: Saite) -> Bool in   Rückkehr S1 > S2 } 

Aus Gründen der Kürze und Ausdruckskraft können die Parametertypen und der Rückgabetyp weggelassen werden, wenn diese abgeleitet werden können:

{ S1, S2 in Rückkehr S1 > S2 } 

In ähnlicher Weise unterstützt SWIFT implizite Rückgabeberechnungen auch für Schließungen mit einem Statement:

{ S1, S2 in S1 > S2 } 

Schließlich können auch die Parameternamen weggelassen werden; Bei weggelassener Parameter werden die Parameter unter Verwendung von Kurzargumentnamen referenziert, bestehend aus dem $ -Symbol, gefolgt von ihrer Position (z. B. $ 0, $ 1, $ 2 usw.):

{ $ 0 > $ 1 } 

Tcl

Im TclDie anonyme Quadratfunktion auf 2 Looks wie folgt anwenden:^[68]

anwenden {x {expr {$ x*$ x}}} 2 # Gibt 4 zurück 

Dieses Beispiel beinhaltet zwei Kandidaten für das, was es bedeutet, a zu sein Funktion In TCL. Der generischste wird normalerweise als a genannt Befehlspräfixund wenn die Variable f Hält eine solche Funktion, dann den Weg zur Ausführung des Funktionsanwendung f(x) wäre

{*}$ f $ x 

wo {*} ist das Expansionspräfix (neu in TCL 8.5). Das Befehlspräfix im obigen Beispiel wird angewendet {x {expr {$ x*$ x}}} Befehlsnamen können an Befehlspräfixe mithilfe der gebunden werden Interp alias Befehl. Befehlspräfixe Support Currying. Befehlspräfixe sind in TCL sehr häufig Apis.

Der andere Kandidat für "Funktion" in TCL wird normalerweise als a genannt Lambdaund erscheint als die {x {expr {$ x*$ x}}} Teil des obigen Beispiels. Dies ist der Teil, der die kompilierte Form der anonymen Funktion zwischengespeichert, kann aber nur durch Übergabe an die angerufen werden anwenden Befehl. Lambdas unterstützt kein Currying, es sei denn, sie werden mit einem gepaart anwenden So bilden Sie ein Befehlspräfix. Lambdas sind in TCL -APIs selten.

Vala

Im ValaAnonyme Funktionen werden als Lambda -Ausdrücke unterstützt.^[69]

delegieren int Intop (int x, int y); Leere hauptsächlich () { 	Intop Foo = (x, y) => x * y; 	Stdout.printf("%d\n", Foo(10,5)); } 

Visual Basic .net

Visual Basic .net 2008 führte anonyme Funktionen durch die Lambda -Form ein. In Kombination mit der impliziten Typisierung bietet VB eine wirtschaftliche Syntax für anonyme Funktionen. Wie bei Python müssen in VB.NET anonyme Funktionen in einer Zeile definiert werden. Sie können nicht zusammengesetzte Aussagen sein. Darüber hinaus muss eine anonyme Funktion in VB.NET wirklich ein VB.NET sein Funktion - Es muss einen Wert zurückgeben.

Schwach Foo = Funktion(x) x * x Konsole.Schreiben(Foo(10)) 

Visual Basic.net 2010 Unterstützung für Multiline -Lambda -Ausdrücke und anonyme Funktionen ohne Rückgabewert. Zum Beispiel eine Funktion zur Verwendung in einem Thread.

Schwach t Wie Neu System.Fäden.Faden(Sub ()  Zum n Wie Ganze Zahl = 0 Zu 10  'Zähl bis 10  Konsole.Schreiben(n)  'Drucken Sie jede Nummer aus  Nächste  Ende Sub  ) t.Anfang() 

Siehe auch

• Erstklassige Funktion

Verweise

Externe Links

• Anonyme Methoden - Wann sollten sie verwendet werden? (Blog über anonyme Funktion in Delphi)
• Kompilien von Lambda -Ausdrücken: Scala gegen Java 8
• PHP Anonyme Funktionen PHP Anonyme Funktionen
• Lambda funktioniert in verschiedenen Programmiersprachen