Tekst źródłowy strony Funkcja anonimowa

'''Funkcja anonimowa''' (również '''literał funkcyjny''' lub '''lambda-abstrakcja''') – definicja [[Podprogram|funkcji]], która sama w sobie nie jest powiązana z [[Identyfikator (programowanie)|identyfikatorem]] (chociaż może być przypisana do zmiennej).

Funkcje anonimowe mogą być<ref>[http://learnyouahaskell.com/higher-order-functions "Higher order functions"]. learnyouahaskell.com</ref>:
# argumentami przekazywanymi [[Funkcja wyższego rzędu|funkcjom wyższego rzędu]] lub
# używane do budowania wyniku funkcji wyższego rzędu, która musi zwracać funkcję.

Jeśli funkcja jest używana tylko jeden raz lub ograniczoną liczbę razy, użycie funkcji anonimowej może być syntaktycznie wygodniejsze niż użycie funkcji nazwanej. Funkcje anonimowe są wszechobecne w [[Programowanie funkcyjne|funkcyjnych językach programowania]] i innych językach z obecnymi funkcjami pierwszego rzędu, gdzie pełnią taką samą rolę dla [[Typ danych|typu funkcji]] jak [[literał]]y dla innych  [[Typ danych|typów danych]].

Funkcje anonimowe biorą początek w pracach [[Alonzo Church]]a nad wynalezieniem [[Rachunek lambda|rachunku lambda]] w 1936 roku (przed pojawieniem się komputerów elektronicznych), w którym wszystkie funkcje są anonimowe<ref>Fernandez, Maribel (2009), [https://books.google.com/books?id=FPFsnzzebhQC&pg=PA33 ''Models of Computation: An Introduction to Computability Theory''], Undergraduate Topics in Computer Science, Springer Science & Business Media, p. 33, {{ISBN|9781848824348}}, <q>The Lambda calculus ... was introduced by Alonzo Church in the 1930s as a precise notation for a theory of anonymous functions</q></ref>. Przejawia się to między innymi tym, że w niektórych językach programowania, funkcje anonimowe są tworzone faktycznie przez użycie słowa kluczowego '''lambda.''' Ponadto funkcje anonimowe są często nazywane lambdami lub lambda-abstrakcjami. Funkcje anonimowe to jedna z charakterystycznych cech [[Język programowania|języków programowania]] od czasu powstania języka [[Lisp]] w 1958 roku i coraz większa liczba nowoczesnych języków programowania wspiera funkcje anonimowe.

Funkcje anonimowe są rodzajem funkcji zagnieżdżonych, zapewniając dostęp do zmiennych w zasięgu funkcji zawierającej (zmiennych nielokalnych). Oznacza to, że anonimowe funkcje powinny być implementowane z wykorzystaniem [[Domknięcie (programowanie)|domknięć]]. W przeciwieństwie do nazwanych funkcji zagnieżdżonych, nie mogą one być [[Rachunek lambda|rekurencyjne]] bez zastosowania [[Operator paradoksalny|operatora punktu stałego]] (również znanego jako ''anonimowe mocowanie'' lub ''anonimowa rekursja'') lub przypisywania ich do nazwy<ref>[https://www.cs.cornell.edu/Courses/cs3110/2012sp/lectures/lec29-fixpoints/lec29.html "Lecture 29: Fixpoints and Recursion"].</ref>.

== Zastosowanie ==
Funkcje anonimowe mogą być wykorzystane, by zawierać w sobie funkcjonalności, które nie powinny być nazwane oraz, być może mają jedynie krótkotrwały użytek. Niektóre przykłady, o których warto wspomnieć, obejmują [[Domknięcie (programowanie)|domknięcia]] i [[currying]].

Funkcje anonimowe to kwestia stylu programowania. Ich stosowanie nie jest wymagane. W dowolnym miejscu, w którym można ich użyć, można także zdefiniować specjalną nazwaną funkcję, która działa dokładnie tak samo. Niektórzy programiści wykorzystują funkcje anonimowe dla [[Hermetyzacja (informatyka)|hermetyzacji]] niektórych fragmentów kodu, w ten sposób odbierając możliwość ponownego wykorzystania, co zapobiega zaśmiecaniu kodu wieloma małymi jednowierszowymi nazwanymi funkcjami.

W niektórych językach programowania, można określić anonimową funkcję wykonaną dla specjalnego zastosowania, aby dać właśnie to (i tylko), czego chce programista, co jest bardziej wydajne, eleganckie i mniej podatne na błędy pewnych operacji, które korzystają ze stałych wartości.

Cały kod w następujących sekcjach został napisany [[Python|języku Python]] 2.x (nie 3.x).

=== Sortowanie ===
Podczas próby sortowania w niestandardowy sposób może być łatwiej zawrzeć logikę porównania w funkcji anonimowej, niż tworzyć funkcję nazwaną. Większość języków zapewniają generyczną funkcję sortowania, która realizuje [[Sortowanie|algorytm sortowania]], który może sortować obiekty dowolnego typu. Funkcja ta zwykle przyjmuje dowolną funkcję porównującą, która przyjmuje dwa argumenty i określa, czy są równe lub czy pierwszy jest „większy” bądź „mniejszy” od drugiego (zwykle zwracając liczbę ujemną, zero lub dodatnią).

Rozważmy sortowanie listy łańcuchów po długości poszczególnych elementów:<syntaxhighlight lang="python">
>>> a = ['dom', 'samochód', 'rower']
>>> a.sort(lambda x,y: cmp(len(x), len(y)))
>>> print(a)
['samochód', 'rower', 'dom']
</syntaxhighlight>

Funkcja anonimowa w tym przykładzie to wyrażenie lambda:<syntaxhighlight lang="python">
lambda x,y: cmp(...)
</syntaxhighlight>

Anonimowa funkcja przyjmuje dwa argumenty: <code>x</code> i <code>u=y</code> oraz zwraca ich porównanie, korzystając z wbudowanej funkcji <code>cmp()</code>.

Inny przykład to sortowanie listy elementów według nazw ich klas (w języku Python, wszystko ma klasę):<syntaxhighlight lang="python">
>>> a = [10, 'liczba', 11.2]
>>> a.sort(lambda x,y: cmp(x.__class__.__name__, y.__class__.__name__))
>>> print(a)
[11.2, 10, 'liczba']
</syntaxhighlight>

Należy pamiętać, że nazwa klasy <code>11.2</code> to „<code>float</code>”, nazwa klasy <code>10</code> to „<code>int</code>”, i nazwa klasy <code>'liczba'</code> to „<code>str</code>”. W posortowanej kolejności-to „<code>float</code>”, „<code>int</code>”, a potem „<code>str</code>”.

=== Domknięcia ===
Domknięcia to funkcje ewaluowane w środowisku zawierające zmienne o ustalonych wartościach. Poniższy przykład przypisuje „wartość graniczną ({{K|en|threshold}})” zmiennej w funkcji anonimowej, która porównuje wejście do argumentu <var>threshold</var>.<syntaxhighlight lang="python">
def comp(threshold):
    return lambda x: x < threshold
</syntaxhighlight>

Może to być używane jako swego rodzaju generator funkcji porównania:<syntaxhighlight lang="python">
>>> func_a = comp(10)
>>> func_b = comp(20)

>>> print func_a(5), func_a(8), func_a(13), func_a(21)
True True False False

>>> print func_b(5), func_b(8), func_b(13), func_b(21)
True True True False
</syntaxhighlight>

Byłoby niepraktyczne tworzenie funkcji nazwanej dla każdej możliwej funkcji porównującej, a zachowywanie wartości granicznej dla przyszłych zastosowań byłoby absolutnie nieeleganckie. Niezależnie od przyczyny zastosowanie domknięcia funkcja anonimowa to jednostka, która zawiera funkcjonalność wykonywania porównania.

=== Currying ===
Currying to proces modyfikacji funkcji tak, aby przyjmowała mniejszą ilość argumentów (w tym przypadku, transformujemy funkcję, która wykonuje [[dzielenie]] przez liczbę całkowitą, w taką która wykonuje dzielenie przez jeden, ustalony dzielnik).<syntaxhighlight lang="python">
>>> def dziel(x, y):
... return x / y

>>> def dzielenie(d):
... return lambda x: dziel(x, d)

>>> naPol = dzielenie(2)
>>> naTrzy = dzielenie(3)

>>> print naPol(32), naTrzy(32)
16 10

>>> print naPol(40), naTrzy(40)
20 13
</syntaxhighlight>

Podczas gdy korzystanie z anonimowych funkcji razem z curryingiem nie jest może zbyt powszechne, to wciąż może być stosowane. W powyższym przykładzie funkcja ''dzielenie'' generuje funkcję dzielącą przez określony dzielnik. Funkcje ''naPol ''oraz ''naTrzy'' tworzą funkcje podziału o stałych dzielnikach.

Funkcja ''dzielenie'' tworzy również domknięcie poprzez przypisanie zmiennej „<var>d</var>” wartości.

=== Funkcje wyższego rzędu ===
Python 2.x zawiera kilka funkcji, które pobierają jako argument anonimowe funkcje. W tej sekcji opisano niektóre z nich.

==== Map ====
Funkcja Map wykonuje wywołanie funkcji dla każdego elementu listy. W poniższym przykładzie [[Kwadrat (algebra)|podnosi do kwadratu]] każdy element tablicy, korzystając z funkcji anonimowej.<syntaxhighlight lang="python">
>>> a = [1, 2, 3, 4, 5, 6]
>>> print map(lambda x: x*x, a)
[1, 4, 9, 16, 25, 36]
</syntaxhighlight>

Anonimowa funkcja przyjmuje argument, który mnoży z samym sobą (podnosi go do kwadratu).

==== Filter ====
Funkcja ''filter'' zwraca wszystkie elementy z listy, które przekazane jako argument do określonej wcześniej funkcji wartościują ją na True.<syntaxhighlight lang="python">
>>> a = [1, 2, 3, 4, 5, 6]
>>> print filter(lambda x: x % 2 == 0, a)
[2, 4, 6]
</syntaxhighlight>

W powyższym przykładzie anonimowa funkcja sprawdza, czy przekazany mu argument jest parzysty.

==== Fold ====
Funkcje'' fold/reduce ''(składanie/redukowanie) przechodzą po wszystkich elementach na liście (zwykle od lewej do prawej), nagromadzając je, w określony sposób, do pewnej wartości. Powszechne wykorzystywane są, aby zredukować wszystkie elementy listy do jednej wartości, np.:<syntaxhighlight lang="python">
>>> a = [1, 2, 3, 4, 5]
>>> print reduce(lambda x,y: x*y, a)
120
</syntaxhighlight>

Co wykonuje
: <math>\Big(\big((1 \cdot 2) \cdot 3\big) \cdot 4\Big) \cdot 5 = 120</math>.

Zaprezentowana tutaj funkcja anonimowa mnoży dwie wartości.

Wynikiem funkcji ''fold'' nie musi koniecznie być jedna wartość - właściwie rzecz biorąc funkcje ''map'' i ''filter'' mogą być zaimplementowane z użyciem ''fold''. W przypadku funkcji ''map'', wartość nagromadzona to nowa lista, zawierająca wyniki wywołania funkcji dla każdego elementu listy oryginalnej. W ''filter'', wartość nagromadzona to nowa lista zawierająca tylko te elementy, które spełniają określony warunek.

== Lista języków ==
Poniżej znajduje się lista [[Język programowania|języków programowania]], które w pełni obsługują nienazwane funkcje anonimowe, wspierają jakiś wariant funkcji anonimowych lub nie mają wsparcia dla funkcji anonimowych.

Ta tabela pokazuje pewne ogólne trendy. Po pierwsze, języki, które nie obsługują funkcji anonimowych – [[C (język programowania)|C]], [[Pascal (język programowania)|Pascal]], [[Object Pascal]] – są konwencjonalnymi, statycznie pisanymi językami. To jednak nie oznacza, że statycznie wpisane języki są niezdolne do obsługi funkcji anonimowych. Na przykład, języki z rodziny [[Meta Language|ML]] są statycznie typowane, jednak fundamentalnie zawierają funkcje anonimowe, a język Delphi, dialekt [[Object Pascal]], został rozbudowany o wsparcie funkcji anonimowych. Po drugie, języki które traktują funkcje jako funkcje pierwszego rzędu – Dylan, [[JavaScript]], [[Lisp]], [[Scheme]], [[Meta Language|ML]], [[Haskell]], [[Python]], [[Ruby (język programowania)|Ruby]], [[Perl]] – generalnie posiadają wsparcie dla funkcji anonimowych, co oznacza, że funkcje mogą być definiowane i przekazywane z taką samą łatwością jak inne typy danych. Gdyby ktoś nie uznawał powyższych przykładów za wystarczające, to wystarczy wspomnieć, że standard [[C++11]] dodaje funkcje anonimowe do [[C++]], czyli do języka konwencjonalnego, statycznie typowanego.

{| class="wikitable" style="text-align: left; font-size: 0.92em; margin-bottom: 10px;"
! Język
! Wsparcie
! Notki
|-
| [[ActionScript]]
| {{tabela-tak}}
|
|-
| [[Ada (język programowania)|Ada]]
| {{tabela-nie}}
| Wyrażenia funkcyjne są częścią Ada2012
|-
| ALGOL 68
| {{tabela-tak}}
|
|-
| [[Brainfuck]]
| {{tabela-nie}}
|
|-
| [[Bash]]
| {{tabela-częściowo}}
| Stworzono bibliotekę w celu dodania wsparcia dla funkcji anonimowych<ref>[https://github.com/spencertipping/bash-lambda "Bash lambda"].</ref>.
|-
| [[C (język programowania)|C]]
| {{tabela-nie}}
| Wsparcie jest zapewniane w [[clang]], wraz z llvm compiler-rt lib. Wsparcie w GCC jest udostępnione jako implementacja w makrach. Szczegóły zobacz niżej.
|-
| [[C Sharp|C#]]
| {{tabela-tak}}
|
|-
| [[C++]]
| {{tabela-tak}}
|Część standardu [[C++11]]<br>
|-
| CFML
| {{tabela-tak}}
|Wraz z Railo 4<ref>{{Cytuj stronę | url = http://www.getrailo.org/index.cfm/whats-up/railo-40-beta-released/features/closures/ | tytuł = "Closure support" | opublikowany = getrailo.org | archiwum = https://web.archive.org/web/20140106031957/http://www.getrailo.org/index.cfm/whats-up/railo-40-beta-released/features/closures/ | zarchiwizowano = 2014-01-06}}.</ref> / [[Adobe ColdFusion|ColdFusion]] 10<ref>{{Cytuj stronę |url=https://learn.adobe.com/wiki/display/coldfusionen/Whats+new+in+ColdFusion+10 |tytuł="Whats new in ColdFusion 10" |data dostępu=2016-02-10 |archiwum=https://web.archive.org/web/20140106032853/https://learn.adobe.com/wiki/display/coldfusionen/Whats+new+in+ColdFusion+10 |zarchiwizowano=2014-01-06}}</ref>
|-
| [[Clojure]]
| {{tabela-tak}}
|
|-
| [[COBOL]]
| {{tabela-nie}}
|Niestandardowy dialekt języka Managed COBOL: Micro Focus wspiera lambdy, nazwane anonimowymi delegatami/metodami<ref>[http://documentation.microfocus.com/help/topic/com.microfocus.eclipse.infocenter.visualcobol.vs/GUID-DA75663F-6357-4064-8112-C87E7457DE51.html "Managed COBOL Reference"].</ref>.
|-
| Curl
| {{tabela-tak}}
|
|-
| [[D (język programowania)|D]]
| {{tabela-tak}}
|
|-
| [[Dart (język programowania)|Dart]]
| {{tabela-tak}}
|
|-
| [[Delphi(język programowania)|Delphi]]
| {{tabela-tak}}
|
|-
| Dylan
| {{tabela-tak}}
|
|-
| [[Eiffel (język programowania)|Eiffel]]
| {{tabela-tak}}
|
|-
| [[Erlang (język programowania)|Erlang]]
| {{tabela-tak}}
|
|-
| [[F Sharp|F#]]
| {{tabela-tak}}
|
|-
| Factor
| {{tabela-tak}}
| Wsparcie przez „Cudzysłowia”<ref>[http://docs.factorcode.org/content/article-quotations.html "Quotations - Factor Documentation"]</ref>
|-
| [[Fortran]]
| {{tabela-nie}}
|
|-
| Frink
| {{tabela-tak}}
|
|-
| [[Go (język programowania)|Go]]
| {{tabela-tak}}
|
|-
| Gosu
| {{tabela-tak}}
|
|-
| [[Groovy]]
| {{tabela-tak}}
|
|-
| [[Haskell]]
| {{tabela-tak}}
|
|-
| [[HaXe]]
| {{tabela-tak}}
|
|-
| [[Java]]
| {{tabela-tak}}
| Wspierane od Java 8.
|-
| [[JavaScript]]
| {{tabela-tak}}
|Nazywane ''funkcjami strzałkowymi'' ({{ang.|arrow functions}}) ze względu na swoją formę: <code>(a, b) => a * b</code>. Dostępne od [[ECMAScript|ES2015]].
|-
| Julia
| {{tabela-tak}}
|
|-
| [[Lisp]]
| {{tabela-tak}}
|
|-
| Logtalk
| {{tabela-tak}}
|
|-
| [[Lua]]
| {{tabela-tak}}
|
|-
| [[MUMPS]]
| {{tabela-nie}}
|
|-
| [[Mathematica]]
| {{tabela-tak}}
|
|-
| [[Maple]]
| {{tabela-tak}}
|
|-
| [[MATLAB]]
| {{tabela-tak}}
|
|-
| [[Maxima]]
| {{tabela-tak}}
|
|-
| [[OCaml]]
| {{tabela-tak}}
|
|-
| [[GNU Octave|Octave]]
| {{tabela-tak}}
|
|-
| [[Object Pascal]]
| {{tabela-częściowo}}
| Delphi, dialekt Object Pascal, implementuje natywne wsparcie dla anonimowych funkcji (formalnie ''metod anonimowych'' (ang. {{K|en|anonymous methods}})) od konferencji Delphi 2009. Dialekt [[Oxygene (język programowania)|Oxygene]] również je wspiera.
|-
| [[Objective-C]] (Mac OS X 10.6+)
| {{tabela-tak}}
| Nazywane blokami; ponadto bloki Objective-C, mogą być wykorzystywane również w C i C++, gdy programujemy na platformie firmy Apple.
|-
| [[Pascal (język programowania)|Pascal]]
| {{tabela-nie}}
|
|-
| [[Perl]]
| {{tabela-tak}}
|
|-
| PHP
| {{tabela-tak}}
| Od PHP 5.3.0 prawdziwe funkcje anonimowe są wspierane; wcześniej istniało tylko częściowe wsparcie dla funkcji anonimowych, które działało podobnie do implementacji w C#.
|-
| PL/I
| {{tabela-nie}}
|
|-
| [[Python]]
| {{tabela-częściowo}}
| Python wspiera funkcje anonimowe poprzez składnie lambda, w którym można używać tylko wyrażeń, nie pełnych instrukcji.<br>
|-
| R
| {{tabela-tak}}
|
|-
| Racket
| {{tabela-tak}}
|
|-
| Rexx
| {{tabela-nie}}
|
|-
| RPG
| {{tabela-nie}}
|
|-
| [[Ruby (język programowania)|Ruby]]
| {{tabela-tak}}
| Funkcje anonimowe Ruby, sprowadzone z języka Smalltalk, są nazywane [[Ruby (język programowania)|blokami]].
|-
| Rust
| {{tabela-tak}}
|
|-
| Scala
| {{tabela-tak}}
|
|-
| [[Scheme]]
| {{tabela-tak}}
|
|-
| Smalltalk
| {{tabela-tak}}
| Funkcje anonimowe są nazywane blokami.
|-
| Standard ML
| {{tabela-tak}}
|
|-
| Swift
| {{tabela-tak}}
| Są nazywane domknięciami (ang. {{K|en|Closures}}).
|-
| TypeScript
| {{tabela-tak}}
|
|-
| Tcl
| {{tabela-tak}}
|
|-
| Vala
| {{tabela-tak}}
|
|-
| Visual Basic .NET v9
| {{tabela-tak}}
|
|-
| Visual Prolog v 7.2
| {{tabela-tak}}
|
|-
| Wolfram Language
| {{tabela-tak}}
|}

== Przykłady ==
Liczne języki obsługują funkcje anonimowe, lub podobną funkcjonalność.

=== C (niestandardowe rozszerzenia) ===
Anonimowa funkcje nie są obsługiwane przez standardowy język C, ale są obsługiwane przez niektóre z jego dialektów, takie jak '''gcc''' i '''clang'''.

==== GCC ====
[[GNU Compiler Collection|GCC]] zapewnia wsparcie dla anonimowych funkcji, mieszanych przez funkcje zagnieżdżone i pewne wyrażenia. Ma postać:<syntaxhighlight lang="c">
( { zwracany_typ nazwa_funkcji_anonimowych (parametry) { cialo funkcji } nazwa_funkcji_anonimowych; } )
</syntaxhighlight>

Poniższy przykład działa tylko z [[GNU Compiler Collection|GCC]]. Należy również pamiętać, że ze względu na sposób działania [[Makro|makr]], jeśli twoje ''l_body'' zawiera przecinki poza nawiasami, program się nie skompiluje, jako że [[GNU Compiler Collection|GCC]] używa przecinka jako separatora do następnego argumentu w makro.
Argument <code>l_ret_type</code> może być usunięty, jeśli <code>__typeof__</code> jest dostępny. W przykładzie poniżej, użycie <code>__typeof__</code> na tablicy zwróci wartość testtype *, która może być „wyłuskana”, aby uzyskać właściwą wartość, jeśli to konieczne.

<syntaxhighlight lang="c">
# include <stdio.h>

//* to definicja funkcji anonimowej */
# 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;                                                                                \
for(;i<sizeof(fe_arr)/sizeof(fe_arrType);i++) { fe_arr[i] = fe_fn_body(&fe_arr[i]); } \
}

typedef struct __test
{
  int a;
  int b;
} testtype;

void printout(const testtype * array)
{
  int i;
  for ( i = 0; i < 3; ++ i )
    printf("%d %d\n", array[i].a, array[i].b);
  printf("\n");
}

int main(void)
{
  testtype array[] = { {0,1}, {2,3}, {4,5} };

  printout(array);
  /* funkcja anonimowa jest przekazana jako funkcja do foreach */
  forEachInArray(testtype, array,
    lambda (testtype, (void *item),
    {
      int temp = (*( testtype *) item).a;
      (*( testtype *) item).a = (*( testtype *) item).b;
      (*( testtype *) item).b = temp;
      return (*( testtype *) item);
    }));
  printout(array);
  return 0;
}
</syntaxhighlight>

==== Clang (dla C, C++, Objective-C, Objective-c++) ====
[[Clang]] zapewnia wsparcie dla funkcji anonimowych, zwanych blokami. Bloki mają formę:

<syntaxhighlight lang="c">
^zwracany_typ ( parametry ) { cialo_funkcji }
</syntaxhighlight>

Typ bloków powyżej to <code>zwracany_typ (^)(parametery)</code>.

Wykorzystując powyższe '''bloki''' i [[Grand Central Dispatch|libdispatch]], kod mógłby wyglądać prościej:

<syntaxhighlight lang="c">
# include <stdio.h>
# include <dispatch/dispatch.h>

int main(void) {
  void (^count_loop)() = ^{
    for (int i = 0; i < 100; i++)
      printf("%d\n", i);
    printf("ah ah ah\n");
  };

/* Przekazanie jako parametr innej funkcji */
  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), count_loop);

/* Wywolaj bezposrednio */
  count_loop();

  return 0;
}
</syntaxhighlight>

Kod z blokami musi być kompilowany z <code>-fBlocksRuntime</code> i linkowany z <code>-lBlocksRuntime</code>

=== C++ (od C++11) ===
[[C++11]] oferuje wsparcie dla funkcji anonimowych nazywanymi '''wyrażeniami lambda'''. Lambda-wyrażenia mają postać:

<syntaxhighlight lang="c++">
[domknięcie](parametry) -> zwracany_typ { cialo_funkcji }
</syntaxhighlight>

Przykładową funkcję lambda określa się w następujący sposób:
<syntaxhighlight lang="c++">
[](int x, int y) -> int { return x + y; }
</syntaxhighlight>

C++11 obsługuje również [[Domknięcie (programowanie)|domknięcia]]. Są określane w nawiasach kwadratowych <code>[</code>i <code>]</code> w deklaracji wyrażenia lambda. Mechanizm pozwala tym zmiennym, aby były przekazywane przez wartość lub przez referencje. Poniższa tabela pokazuje różne warianty:
<syntaxhighlight lang="c++">
[] //brak zdefiniowanych zmiennych. Proba uzycia jakichkolwiek zewnetrznych zmiennych w lambdzie to blad.
[x, &y] //x jest przejmowana przez wartosc, y jest przejmowana przez referencje
[&] //jakakolwiek zmienna jest domyslnie przejmowana przez referencje, jesli zostaje uzyta
[=] //jakakolwiek zmienna jest domyslnie przejmowana przez wartosc, jesli zostaje uzyta
[&, x] //x jest jednoznacznie przejmowana przez wartosc. Inne zmienne domyslnie przez referencje
[=, &z] //z jest jednoznacznie przejmowana przez referencje. Inne zmienne domyslnie przez wartosc
</syntaxhighlight>

Zmienne przekazane przez wartość są domyślnie traktowane jako stałe. Dodawanie <code>mutable</code> po liście parametrów sprawia, że będą traktowane jako zmienne tymczasowe.

Następne dwa przykłady pokazują użycie wyrażeń lambda:
<syntaxhighlight lang="c++">
std::vector<int> some_list{ 1, 2, 3, 4, 5 };
int total = 0;
std::for_each(begin(some_list), end(some_list), [&total](int x) {
	total += x;
});
</syntaxhighlight>

Powyższy kod oblicza sumę wszystkich elementów listy. Zmienna <code>total</code> jest przechowywana jako część domknięcia funkcji lambda. Jako że jest to [[Referencja (informatyka)|referencja]] do zmiennej <code>total</code> umieszczonej na stosie, funkcja może zmienić jej wartość.
<syntaxhighlight lang="c++">
std::vector<int> some_list{ 1, 2, 3, 4, 5 };
int total = 0;
int value = 5;
std::for_each(begin(some_list), end(some_list), [&, value, this](int x) {
	total += x * value * this->some_func();
});
</syntaxhighlight>

To spowoduje, że zmienna <code>total</code> będzie przechowywana jako referencja, ale <code>value</code> będzie przechowywana jako kopia.

Przekazywanie zmiennej <code>this</code> jest wyjątkowe. Może być wykonane tylko przez wartość, nie przez referencję. <code>this</code> może być przekazane tylko jeśli najbliższa funkcja zawierająca funkcję nie jest składową statyczną. Lambda będzie miała taki sam dostęp do składowych protected/private jak składowa, która ją utworzyła.

Jeśli <code>this</code> zostaje przekazana, jawnie lub niejawnie, to zasięg otaczających składowych klasy także jest testowany. Dostęp do elementów <code>this</code> nie wymaga jawnego użycia składni <code>this-></code>.

Właściwa wewnętrzna realizacja może się różnić, ale oczekuje się, że funkcji lambda, do której wszystkie argumenty są przekazywane przez referencje, zachowa [[wskaźnik stosu]] funkcji, w której jest utworzona, zamiast indywidualnych referencji do zmiennych stosowych. Jednakże funkcje lambda, ze względu na małe wymiary i lokalność w ramach z zasięgu, są dobrymi kandydatami do zastosowania na nich metody [[Inline (programowanie)|inline]], zatem nie będą wymagać dodatkowego miejsca na referencje.

Jeśli domknięcie, które zawiera referencje do zmiennych lokalnych, jest wywoływane po najniższym wewnętrznym zasięgu bloku, w którym zostało stworzone, to zachowanie jest niezdefiniowane.

Funkcje lambda to obiekty funkcyjne z typem zależnym od [[Implementacja (informatyka)|implementacji]]; nazwa tego typu jest dostępna tylko dla kompilatora. Jeżeli użytkownik życzy sobie pobrania funkcji lambda jako parametru, to jej typ musi być typem parametrycznym lub musi stworzyć <code>std::function</code> lub podobny obiekt, aby uchwycić wartość lambdy. Korzystanie ze słowa kluczowego <code>auto</code> może pomóc w zapisaniu funkcji lambda.

<syntaxhighlight lang="c++">

auto my_lambda_func = [&](int x) { /*...*/ };
auto my_onheap_lambda_func = new auto([=](int x) { /*...*/ });
</syntaxhighlight>

Oto przykład przechowywania funkcji anonimowych w zmiennych, wektorach i macierzach; i przekazania ich jako nazwanych parametrów:<syntaxhighlight lang="c++">
# include <functional>
# include <vector>
# include <iostream>

double eval(std::function <double(double)> f, double x = 2.0)
{
	return f(x);
}

int main()
{
	std::function<double(double)> f0 = [](double x){return 1;};
	auto f1 = [](double x){return x;};
	decltype(f0) fa[3] = {f0,f1,[](double x){return x*x;}};
	std::vector<decltype(f0)> fv = {f0,f1};
	fv.push_back ([](double x){return x*x;});
	for(int i=0;i<fv.size();i++)
		std::cout << fv[i](2.0) << std::endl;
	for(int i=0;i<3;i++)
		std::cout << fa[i](2.0) << std::endl;
	for(auto &f : fv)
		std::cout << f(2.0) << std::endl;
	for(auto &f : fa)
		std::cout << f(2.0) << std::endl;
	std::cout << eval(f0) << std::endl;
	std::cout << eval(f1) << std::endl;
	std::cout << eval([](double x){return x*x;}) << std::endl;
	return 0;
}
</syntaxhighlight>

Wyrażenie lambda z pustym domknięciem (<code>[]</code>) może być niejawnie przekształcone na wskaźnik na funkcję tego samego typu, jak typ, z którym lambda została zadeklarowana. Także to jest poprawne:<syntaxhighlight lang="c++">
auto a_lambda_func = [](int x) { /*...*/ };
void (* func_ptr)(int) = a_lambda_func;
func_ptr(4); //wywoluje lambde
</syntaxhighlight>

Biblioteka [[Boost]] udostępnia własną składnie dla funkcji lambda, korzystając z następującej składni:<ref>Järvi, Jaakko; Powell, Gary (n.d.</ref><syntaxhighlight lang="c++">
for_each(a.begin(), a.end(), std::cout << _1 << ' ');
</syntaxhighlight>

=== C# ===
Obsługa funkcji anonimowych w [[C Sharp|C#]] pogłębiała się w kolejnych wersjach kompilatora języka. Język C# v3.0, wydany w listopadzie 2007 roku z .NET Framework v3.5, cechuje się pełną obsługą funkcji anonimowych. Składnia C# odnosi się do nich jako „wyrażeń lambda”, zgodnie z pierwotnym nazewnictwem funkcji anonimowych w [[Rachunek lambda|rachunku lambda]]. Zobacz [http://www.microsoft.com/download/en/details.aspx?id=7029 Specyfikację Języka C# 4.0], sekcja 5.3.3.29, aby uzyskać więcej informacji.<syntaxhighlight lang="c#">
 // pierwszy int to typ x'
 // drugi int to typ zwracanej wartosci
 // <see href="http://msdn.microsoft.com/en-us/library/bb549151.aspx" />
 Func<int,int> foo = x => x*x; Console.WriteLine(foo(7));
</syntaxhighlight>

Funkcja anonimowa nie może być przypisana do pośrednio typowanej zmiennej, ponieważ składnia wyrażenia lambda może być używany dla oznaczenia funkcji anonimowej lub drzewa wyrażeń, a wybór nie może być podejmowany automatycznie przez [[kompilator]]. Na przykład to nie działa:
<syntaxhighlight lang="csharp">
// NIE skompiluje sie!
var foo = (int x) => x*x;
</syntaxhighlight>

Jednakże wyrażenie lambda może brać udział w [[Parametr (informatyka)|interferencji typów]], np. aby użyć funkcji anonimowej z funkcjonalnością Map dostępną z <code>System.</code><code>Collections.Generic.</code><code>List</code> (w metodzie <code>ConvertAll()</code>):<syntaxhighlight lang="c#">
// Inicjalizowanie listy:
var values = new List<int>() { 7, 13, 4, 9, 3 };
// Mapuj wszystkie elementy listy przez funkcje anonimowa, zwroc nowa liste
var foo = values.ConvertAll(d => d*d) ;
// Rezultat w zmiennej foo jest typu System.Collections.Generic.List<Int32>
</syntaxhighlight>

Poprzednie wersje C# miały bardziej ograniczoną obsługę funkcji anonimowych. C# w wersji v1.0, wprowadzonej w lutym 2002 roku z NET Framework v1.0, zapewniał częściowa obsługę za pomocą [[Delegat (CLI)|delegatów]]. Konstrukcja ta jest bardzo podobna do delegatów w [[PHP]]. W C# 1.0, delegaci są do podobni do wskaźników na funkcje, które odnoszą się do jednoznacznie nazwanej metody wewnątrz klasy. (Ale w przeciwieństwie do PHP nazwa nie jest potrzebna przy użyciu delegata.) C# w wersji v2.0, wydany w listopadzie 2005 roku razem z .NET Framework v2.0, wprowadził pojęcie metod anonimowych, jako sposób na pisanie wstawianych nienazwanych wyrażeń. C# 3.0 kontynuuje wsparcie dla tych konstrukcji, ale wspiera także funkcje lambda.

Ten przykład będzie się kompilować w C# 3.0 i pokazuje wszystkie trzy metody:<syntaxhighlight lang="c#">
    public class TestDriver
    {
        delegate int SquareDelegate(int d);
        static int Square(int d)
        {
            return d*d;
        }

        static void Main(string[] args)
        {
            // C# 1.0: Pierwotna skladnia delegatow wymagala
            // inicjalizacji z metoda nazwana.
            SquareDelegate A = new SquareDelegate(Square);
            System.Console.WriteLine(A(3));

            // C# 2.0: Delegat moze byc zainicjalizowany
            // z kodem typu inline, zwanym „metoda anonimowa”. Ta
            // metoda pobiera int jako parametr.
            SquareDelegate B = delegate(int d) { return d*d; };
            System.Console.WriteLine(B(5));

            // C# 3.0. Delegat moze byc zainicjalizowany poprzez
            // wyrazenie lambda. Lambda pobiera int, oraz zwraca int.
            // Typ x jest wyprowadzany przez kompilator.
            SquareDelegate C = x => x*x;
            System.Console.WriteLine(C(7));

            // C# 3.0. Delegat akceptujacy jedno wejscie
            // zwracajacy jedno wyjscie moze byc posrednio zdefiniowany z typem Func<>.
            System.Func<int,int> D = x => x*x;
            System.Console.WriteLine(D(9));
        }
    }
</syntaxhighlight>

W przypadku C# w wersji 2.0, kompilator C# akceptuje blok kodu funkcji anonimowej i tworzy statyczną funkcję prywatną. Oczywiście, wewnętrznie funkcja ta otrzymuje automatycznie wygenerowaną nazwę, opartą na nazwie metody, w której dokonano deklaracji Delegata. Jednak ta nazwa, z wyjątkiem użycia [[Mechanizm refleksji|refleksji]], nie jest wystawiona na kod aplikacji.

W przypadku 3.0 C#, stosowany jest ten sam mechanizm.

=== CFML ===
<syntaxhighlight lang="sml">
fn = function(){
  // instrukcje
};
</syntaxhighlight>

CFML obsługuje wszelkie instrukcje w definicji funkcji, a nie tylko wyrażenia.

CFML obsługuje rekurencyjne funkcje anonimowe:<syntaxhighlight lang="sml">
factorial = function(n){
    return n > 1 ? n * factorial(n-1) : 1;
};
</syntaxhighlight>

Funkcje anonimowe w CFML implementują domknięcie.

=== D ===
D w celu implementacji funkcji anonimowych wykorzystuje [[delegatów]] [[Inline (programowanie)|inline]]. Pełna składnia dla delegata inline to
<syntaxhighlight lang="d">
zwracany_typ delegate(argumenty){/*cialo*/}
</syntaxhighlight>

Jeśli jest to jednoznaczne, zwracany typ i słowo kluczowe ''delegate'' może być pominięte.<syntaxhighlight lang="d">
(x){return x*x;}
delegate (x){return x*x;} // jezeli wymagane jest wieksza rozleglosc
(int x){return x*x;} // jezeli parametr nie moze byc wyprowadzony
delegate (int x){return x*x;} // ditto
delegate double(int x){return x*x;} // jezeli typ zwracanej wartosci musi byc wymuszony
</syntaxhighlight>

Począwszy od wersji 2.0 D, jeżeli kompilator nie dowiedzie, że jest to niepotrzebne, alokuje domknięcia na stercie. Aby wymusić alokacje na stosie, może być użyte słowo kluczowe <code>scope</code>. Począwszy od wersji 2.058, można użyć skróconej notacji:
<syntaxhighlight lang="d">
x => x*x;
(int x) => x*x;
(x,y) => x*y;
(int x, int y) => x*y;
</syntaxhighlight>

Anonimową funkcję można przypisać do zmiennej i użyć w ten sposób:
<syntaxhighlight lang="d">
auto sqr = (double x){return x*x;};
double y = sqr(4);
</syntaxhighlight>

=== Dart ===
[[Dart (język programowania)|Dart]] wspiera funkcje anonimowe.
<syntaxhighlight lang="dart">
var sqr = (x) => x * x;
print(sqr(5));
</syntaxhighlight>

lub

<syntaxhighlight lang="dart">
print(((x) => x * x)(5));
</syntaxhighlight>

=== Delphi ===
[[Object Pascal|Delphi]] obsługuje funkcje anonimowe, począwszy od wersji 2009.
<syntaxhighlight lang="delphi">
program demo;

type
  TSimpleProcedure = reference to procedure;
  TSimpleFunction = reference to function(x: string): Integer;

var
  x1: TSimpleProcedure;
  y1: TSimpleFunction;

begin
  x1 := procedure
    begin
      Writeln('Hello World');
    end;
  x1;   // wywolanie wlasnie zdefiniowanej metody anonimowej

  y1 := function(x: string): Integer
    begin
      Result := Length(x);
    end;
  Writeln(y1('bar'));
end.
</syntaxhighlight>

=== Erlang ===
[[Erlang (język programowania)|Eгlang]] używa podobnej składni dla funkcji anonimowych jak i funkcji nazwanych.

<syntaxhighlight lang="erlang">
% Funkcja anonimowa przypisana do zmiennej Square
Square = fun(X) -> X * X end.

% Funkcja nazwana o tej samej roli
square(X) -> X * X.
</syntaxhighlight>

=== Go ===
[[Go]] wspiera funkcja anonimowe.
<syntaxhighlight lang="go">
foo := func(x int) int {
	return x * x
}
fmt.Println(foo(10))
</syntaxhighlight>

=== Haskell ===
[[Haskell]] wykorzystuje zwięzłą składnię dla funkcji anonimowych (wyrażeń lambda).

<syntaxhighlight lang="haskell">
 \x -> x * x
</syntaxhighlight>

Wyrażenia lambda są w pełni zintegrowane z silnikiem typowania, i obsługują całą składnie i wszystkie funkcjonalności „zwykłych” funkcji (z wyjątkiem korzystania z wielu definicji dla [[dopasowywania wzorców]], ponieważ lista argumentów jest podawana tylko raz).

<syntaxhighlight lang="haskell">
 map (\x -> x * x) [1..5] -- zwraca [1, 4, 9, 16, 25]
</syntaxhighlight>

Następujące wyrażenia są sobie równoważne:

<syntaxhighlight lang="haskell">
 f x y = x + y
 f x = \y -> x + y
 f = \x y -> x + y
</syntaxhighlight>

=== Haxe ===
W [[HaXe]] funkcje anonimowe nazywane są lambdami i używają składni <code>function(lista argumentow) wyrazenie;</code> .

<syntaxhighlight lang="haxe">
var f = function(x) return x*x;
f(8); // 64
(function(x,y) return x+y)(5,6); // 11
</syntaxhighlight>

=== Java ===
[[Java]] obsługuje funkcji anonimowe począwszy od [[Java Development Kit|wersji JDK 8]]<ref>{{Cytuj | url=http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html | tytuł=What's New in JDK 8<!-- Tytuł wygenerowany przez bota --> | opublikowany=www.oracle.com | data dostępu=2017-11-18}}</ref>. W języku java, funkcje anonimowe nazywane są ''Wyrażeniami Lambda (ang. {{K|en|Lambda Expressions}})''.

Wyrażenie lambda składa się z listy oddzielonych przecinkami parametrów formalnych ujętych w nawiasy, markera strzałki ( -> ) i ciała funkcji. Jeśli istnieje tylko jeden parametr, typy danych parametrów, jak i nawiasy mogą zostać pominięte. Ciało może składać się z jednej instrukcji lub bloku instrukcji<ref name="JavaLambda">[http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html ''The Java Tutorials: Lambda Expressions''], docs.oracle.com</ref>.

<syntaxhighlight lang="java">
// Bez parametru
() -> System.out.println("Hello, world.")

// Z jednym parametrem (To przykład odzorowania identycznosciowego).
a -> a

// Z prostym wyrazeniem
(a, b) -> a + b

// Z jasna informacja o typie
(long id, String name) -> "id: " + id + ", name:" + name

// Z blokiem kodu
(a, b) -> { return a + b; }

// Z wieloma instukcjami w ciele funkcji. Wymagany jest blok kodu
// Ten przyklad zawiera zagniezdzone wyrazenia lambda (pierwsza jest take domknieciem).
(id, defaultPrice) -> {
  Optional product = productList.stream().filter(p -> p.getId() == id).findFirst();
  return product.map(p -> p.getPrice()).orElse(defaultPrice);
}
</syntaxhighlight>

Wyrażenia lambda są konwertowane na „interfejsy funkcjonalne” (definiowane jako interfejsy, które oprócz jednej czy więcej metod domyślnych lub statycznych zawierają tylko jedną metodę abstrakcyjną<ref name="JavaLambda" />), jak pokazano w poniższym przykładzie:

<syntaxhighlight lang="java">
public class Calculator {
    interface IntegerMath {
        int operation(int a, int b);

        default IntegerMath swap() {
          return (a, b) -> operation(b, a);
        }
    }

    private static int apply(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }

    public static void main(String... args) {
        IntegerMath addition = (a, b) -> a + b;
        IntegerMath subtraction = (a, b) -> a - b;
        System.out.println("40 + 2 = " + apply(40, 2, addition));
        System.out.println("20 - 10 = " + apply(20, 10, subtraction));
        System.out.println("10 - 20 = " + apply(20, 10, subtraction.swap()));
    }
}
</syntaxhighlight>

W tym przykładzie zostaje zadeklarowany interfejs funkcjonalny o nazwie <code>IntegerMath</code>. Wyrażenia lambda, implementujące <code>IntegerMath</code> są przekazywane do metody <code>apply()</code> w celu ich wykonana. Domyślne metody, takie jak <code>swap</code> określają metody, które można wykonać na funkcjach.

=== JavaScript ===
[[JavaScript]]/[[ECMAScript]] obsługuje funkcje anonimowe.

<syntaxhighlight lang="javascript">
alert((function(x){
	return x*x;
})(10));
</syntaxhighlight>

W [[ECMAScript|ES6]]:

<syntaxhighlight lang="javascript">
alert((x => x*x)(10));
</syntaxhighlight>

Konstrukcja ta jest często używane w [[Skryptozakładka|Bookmarkletach]]. Na przykład, aby zmienić nazwę bieżącego dokumentu (widoczne w tytule okna przeglądarki) na jego [[Uniform Resource Locator|adres URL]], następny bookmarklet może sprawiać wrażenie działającego prawidłowo.

<syntaxhighlight lang="javascript">
javascript:document.title=location.href;
</syntaxhighlight>

Jednak, ponieważ [[instrukcja przypisania]] zwraca wartość (sam adres URL), wiele przeglądarek tworzy nową stronę, aby wyświetlić wartość.

Stosując zamiast tego funkcje anonimową, która nie zwraca wartości:

<syntaxhighlight lang="javascript">
javascript:(function(){document.title=location.href;})();
</syntaxhighlight>

Instrukcja ''function'' w pierwszej (zewnętrznej) parze nawiasów deklaruje anonimową funkcje, która zostaje później wykonana, o czym świadczy składnia z ostatnimi pustymi nawiasami. Jest to prawie równoznaczne z kodem zaprezentowanym poniżej, który tworzy zmienną <code>f</code>.

<syntaxhighlight lang="javascript">
javascript:var f = function(){document.title=location.href;}; f();
</syntaxhighlight>

Należy korzystać z [[Skryptozakładka|void()]], aby uniknąć nowych stron przy wykonywaniu funkcji anonimowych:
<syntaxhighlight lang="javascript">
javascript:void(function(){return document.title=location.href;}());
</syntaxhighlight>

lub bez użycia funkcji anonimowej:

<syntaxhighlight lang="javascript">
javascript:void(document.title=location.href);
</syntaxhighlight>

JavaScript posiada subtelne reguły semantyczne dotyczące definiowania, wywoływania oraz ewaluowania funkcji anonimowych. Te trudno dostrzegalne niuanse są bezpośrednią konsekwencją ewaluacji wyrażeń. Poniższe konstrukcje nazywane natychmiastowo-wywoływanymi wyrażeniami funkcyjnymi (ang. {{K|en|immediately-invoked function expression}}) dobrze to ilustrują:

<syntaxhighlight lang="javascript">
(function(){ ... }())
</syntaxhighlight>

i

<syntaxhighlight lang="javascript">
(function(){ ... })()
</syntaxhighlight>

Skracając zapis „<code>function(){ ... }</code>” przez <code>f</code>, formy konstrukcji są odpowiednio wyrażeniem w nawiasach wewnątrz wyrażenia w nawiasach <code>(f())</code> i wyrażeniem w nawiasach <code>(f)()</code> wykonanym przez wyrażenie w nawiasach.

Należy zwrócić uwagę na ogólne niejasności składniowe wyrażeń w nawiasach, argumentów funkcji w nawiasach, oraz argumentów formalnych definicji funkcji podanych w nawiasach. W szczególności, JavaScript definiuje operator <code>,</code> (przecinek) w kontekście wyrażeń w nawiasach. Nie jest to przypadkiem, że formy składniowe pokrywają się dla wyrażenia oraz argumentów funkcji (ignorując składnie argumentów formalnych funkcji)! Jeśli <code>f</code> nie jest zdefiniowane w wyrażeniu powyżej, staje się one <code>(())</code> i <code>()()</code>. Pierwszy nie zapewnia podpowiedzi składniowej odnośnie do funkcji wewnątrz ale drugi MUSI ewaluować pierwszy [[nawias]] jako funkcję, aby być prawidłowym kodem JavaScript. (Oprócz tego: przykładowo <code>()</code> może być ([],{},42,"Abc",function () {}), byleby wyrażenie ewaluowało się jako funkcja.)

Ponadto, funkcja jest instancją obiektu (podobnie obiekty są instancjami funkcji), a notacja dla literałów obiektów, <code>{}</code>dla kodu w klamrach, jest używana przy definiowaniu funkcji w taki sposób (w przeciwieństwie do korzystania z <code>new Function(...)</code>). W najszerszym nieścisłym sensie (szczególnie z uwzględnieniem naruszenia powiązań globalnych), dowolna sekwencja instrukcji JavaScript w klamrach, <code>{stuff}</code>, może być traktowana jako [[punkt stały]] poniższego wyrażenia

<syntaxhighlight lang="javascript">
(function(){( function(){( ... {( function(){stuff}() )} ... )}() )}() )
</syntaxhighlight>

Bardziej poprawnie, ale z zastrzeżeniami

<syntaxhighlight lang="javascript">
( function(){stuff}() ) ~=
   A_Fixed_Point_of(
      function(){ return function(){ return ... { return function(){stuff}() } ... }() }()
)
</syntaxhighlight>

Należy zwrócić uwagę na konsekwencje zastosowania funkcji anonimowych we fragmentach JavaScript, poniżej:
* <code>function(){ ... }()</code> bez otaczających <code>()</code>, zwykle nie jest prawidłowa
* <code>(f=function(){ ... })</code> nie „zapomnina” globalnie o <code>f</code> w przeciwieństwie do <code>(function f(){ ... }</code><code></code>
::: [[Metryka oprogramowania|Wskaźniki wydajności]] do analizy [[Złożoność obliczeniowa|złożoności przestrzennej i czasowej]] wywołania funkcji, wywołań na stosie, itp. [[Interpreter (program komputerowy)|silnika interpretera]] JavaScript dają się łatwo zaimplementować za pomocą powyższej konstrukcji funkcji anonimowych. Z interpretacji wyników można pozyskać pewne wiadomości odnośnie do implementacji silnika, dotyczące wydajności iteracji oraz rekursji, a w szczególności [[Rekurencja ogonowa|rekurencji ogonowej]].

=== Julia ===
W języku Julia funkcje anonimowe są definiowane przy użyciu składni <code>(argumenty)->(wyrażenie)</code>,<syntaxhighlight lang="julia">
julia> f = x -> x*x; f(8)
64
julia> ((x,y)->x+y)(5,6)
11
</syntaxhighlight>

=== Lisp ===
[[Lisp]] i [[Scheme]] obsługują funkcje anonimowe z pomocą konstrukcji „lambda”, które odnoszą się do [[Rachunek lambda|rachunku lambda]]. [[Clojure]] obsługuje funkcje anonimowe za pomocą konstrukcji „fn” oraz makra #() czytnika.<syntaxhighlight lang="lisp">
(lambda (arg) (* arg arg))
</syntaxhighlight>

==== Common Lisp ====
[[Common Lisp]] zawiera koncepcje wyrażeń lambda. Wyrażenie lambda jest zapisywane w postaci listy z symbolem „lambda” jako pierwszy element. Lista zawiera także listę argumentów, dokumentacji i deklaracji, oraz ciało funkcji. Wyrażenia lambda mogą być używane wewnątrz innej lambdy ze specjalnym operatorem „function”.<syntaxhighlight lang="common-lisp">
(function (lambda (arg) (do-something arg)))
</syntaxhighlight>

„function” może być zapisane w skrócie jako #'. Ponadto istnieje makro „lambda”, które rozwija się do postaci funkcji:<syntaxhighlight lang="common-lisp">
; Uzywajac ostrego cudzyslowia
# '(lambda (arg) (do-something arg))
; Uzywajac makra lambda:
(lambda (arg) (do-something arg))
</syntaxhighlight>

Jednym z typowych zastosowań funkcji anonimowych w Common Lisp jest przekazywanie ich funkcjom wyższego rzędu jak „mapcar”. „mapcar” wywołuje funkcje dla każdego elementu listy i zwraca listę jako rezultat.<syntaxhighlight lang="common-lisp">
(mapcar #'(lambda (x) (* x x))
        '(1 2 3 4))
; -> (1 4 9 16)
</syntaxhighlight>

„lambda formy” w Common Lisp pozwalają „wyrażeniom lambda” na bycie używanymi w wywołaniach funkcji:<syntaxhighlight lang="common-lisp">
((lambda (x y)
   (+ (sqrt x) (sqrt y)))
 10.0
 12.0)
</syntaxhighlight>

Funkcje anonimowe w Common Lisp mogą, po uprzedniej definicji, mieć nadawane nazwy:<syntaxhighlight lang="common-lisp">
(setf (symbol-function 'sqr)
      (lambda (x) (* x x)))
; co pozwala na jej wywolanie przy uzyciu identyfikatora SQR:
(sqr 10.0)
</syntaxhighlight>

==== Scheme ====
Co ciekawe, „funkcje nazwane” - to po prostu [[Lukier składniowy|cukier syntaktyczny]] dla funkcji anonimowych powiązanych z nazwami:<syntaxhighlight lang="scheme">
(define (somename arg)
  (do-something arg))
</syntaxhighlight>

rozwija się do (jest równoważne z)<syntaxhighlight lang="scheme">
(define somename
  (lambda (arg)
    (do-something arg)))
</syntaxhighlight>

==== Clojure ====
[[Clojure]] obsługuje funkcje anonimowe za pomocą konstrukcji „fn”:<syntaxhighlight lang="clojure">
(fn [x] (+ x 3))
</syntaxhighlight>

Istnieje również składnia czytnika służąca do definicji wyrażenia lambda:<syntaxhighlight lang="clojure">
# (+ % %2%3) ; Definiuje funkcje anonimowa, która pobiera trzy argumenty i je sumuje.
</syntaxhighlight>

Jak Scheme, „funkcje nazwane” Clojure to po prostu cukier syntaktyczny dla wyrażeń lambda związanych z nazwami:<syntaxhighlight lang="clojure">
(defn func [arg] (+ 3 arg))
</syntaxhighlight>

rozwija się do:<syntaxhighlight lang="clojure">
(def func (fn [arg] (+ 3 arg)))
</syntaxhighlight>

=== Lua ===
W [[Lua]] (jak w Scheme) wszystkie funkcje są anonimowe. Funkcja nazwana w lua-to po prostu zmienna, która przechowuje referencje do obiektu funkcyjnego<ref>[http://www.lua.org/pil/6.html "Programming in Lua - More about Functions"].</ref>.

Tak więc, w lua<syntaxhighlight lang="lua">
function foo(x) return 2*x end
</syntaxhighlight>

to po prostu cukier syntaktyczny dla<syntaxhighlight lang="lua">
foo = function(x) return 2*x end
</syntaxhighlight>

Przykład użycia funkcji anonimowych do sortowania w odwrotnej kolejności:<syntaxhighlight lang="lua">
table.sort(network, function(a,b)
  return a.name > b.name
end)
</syntaxhighlight>

=== Wolfram Language/Mathematica ===
Wolfram Language to język programowania systemu [[Mathematica]]. Funkcje anonimowe są ważnym elementem programowania w systemie Mathematica. Istnieje kilka sposobów ich tworzenia. Poniżej znajduje się kilka funkcji anonimowych, które inkrementują liczbę. Pierwszy sposób jest najbardziej powszechny. '#1' odnosi się do pierwszego argumentu a '&' oznacza koniec funkcji anonimowej.<syntaxhighlight lang="mathematica">
     #1+1&
     Function[x,x+1]
     x \[Function] x+1
</syntaxhighlight>

Tak więc, na przykład:<syntaxhighlight lang="mathematica">
    f:= #1^2&;f[8]
     64
    #1+#2&[5,6]
     11
</syntaxhighlight>

Ponadto, Mathematica ma dodatkową konstrukcję do budowy rekursywnych anonimowych funkcji. Symbol '#0' odnosi się do całej funkcji. Poniższa funkcja oblicza [[Silnia|silnię]] swojego wejścia:<syntaxhighlight lang="mathematica">
     If[#1 == 1, 1, #1 * #0[#1-1]]&
</syntaxhighlight>

=== MATLAB/Octave ===
Funkcje anonimowe w [[GNU Octave]] lub w [[MATLAB]] są definiowane za pomocą składni <code>@(lista-argumentów)wyrażenie</code>. Wszystkie zmienne, które nie znalazły się na liście argumentów, są dziedziczone z zawierającego zasięgu.<syntaxhighlight lang="matlab">
 > f = @(x)x*x; f(8)
 ans = 64
 > (@(x,y)x+y)(5,6) % Dziala tylko w Octave
 ans = 11
</syntaxhighlight>

=== Maxima ===
W języku [[Maxima]] funkcje anonimowe są definiowane przy użyciu składni <code>lambda(list argumentów,wyrażenie)</code>,<pre>
 f: lambda([x],x*x); f(8);
 64

 lambda([x,y],x+y)(5,6);
 11
</pre>

=== ML ===
Przeróżne dialekty [[Meta Language|ML]] wspierają funkcje anonimowe.

==== [[OCaml]] ====
<syntaxhighlight lang="ocaml">
fun arg -> arg * arg
</syntaxhighlight>

==== [[F Sharp|F#]] ====
<syntaxhighlight lang="fsharp">
(fun x -> x * x) 20 // 400
</syntaxhighlight>

==== [[Standard ML]] ====
<syntaxhighlight lang="sml">
fn arg => arg * arg
</syntaxhighlight>

=== Perl ===
==== Perl 5 ====
[[Perl|Perl 5]] wpiera funkcje anonimowe, w następujący sposób:<syntaxhighlight lang="perl">
(sub { print "I got called\n" })->(); # 1. calkowicie anonimowa, wywolywana przy utworzeniu

my $squarer = sub { my $x = shift; $x * $x }; # 2. przypisana do zmiennej

sub curry {
    my ($sub, @args) = @_;
    return sub { $sub->(@args, @_) };         # 3. jako wartosc zwracana przez inna funkcje
}

# przyklad Curryingu w Perl'u
sub sum { my $tot = 0; $tot += $_ for @_; $tot } # zwraca sume argumentow
my $curried = curry \&sum, 5, 7, 9;
print $curried->(1,2,3), "\n"; # wypisuje 27 ( = 5 + 7 + 9 + 1 + 2 + 3 )
</syntaxhighlight>

Inne konstrukcje pobierają „gołe bloki” (ang. {{K|en|bare blocks}}) jako argumenty, co pełni rolę podobną do funkcji lambda z jednym parametrem, w ten sposób nie utrzymując tej samej konwencji przekazywania parametrów, gdyż @_ nie jest ustawione. <syntaxhighlight lang="perl">
my @squares = map { $_ * $_ } 1..10; # map i grep nie uzywaja slowa kluczowego 'sub'
my @square2 = map $_ * $_, 1..10; # nawiasy nie potrzebne dla pojedynczego wyrazenia

my @bad_example = map { print for @_ } 1..10; # przekazywanie wartosci jak normalna funkcja Perl'a
</syntaxhighlight>

==== Perl 6 ====
W języku [[Perl 6]], wszystkie bloki (nawet te, które są związane z if, while itp.) to funkcje anonimowe. Blok, który nie jest używany jako [[L-wartość|R-wartość]], jest wykonywany natychmiast.<syntaxhighlight lang="perl6">
# 1. calkowicie anonimowa, wywolywana przy utworzeniu
{ say "I got called" };

# 2. przypisana do wartosci
my $squarer1 = -> $x { $x * $x }; # 2a. "pointy block"
my $squarer2 = { $^x * $^x }; # 2b. "twigil"
my $squarer3 = { my $x = shift @_; $x * $x }; # 2b. styl Perl 5

# 3. currying
sub add ($m, $n) { $m + $n }
my $seven = add(3, 4);
my $add_one = &add.assuming(m => 1);
my $eight = $add_one($seven);
</syntaxhighlight>

=== PHP ===
Przed wydaniem wersji 4.0.1, PHP nie wspierał funkcji anonimowych<ref>http://php.net/create_function the top of the page indicates this with "(PHP 4 >= 4.0.1, PHP 5)"</ref>.

==== PHP w od 4.0.1 do 5,3 ====
PHP 4.0.1 wprowadził <code>create_function</code>, co było zaczątkiem wsparcia funkcji anonimowych. Wywołanie tej funkcji tworzy nową funkcję z unikatową nazwą (w postaci łańcucha)<syntaxhighlight lang="php">
$foo = create_function('$x', 'return $x*$x;');
$bar = create_function("\$x", "return \$x*\$x;");
echo $foo(10);
</syntaxhighlight>

Funkcja została usunięta w PHP 8 między innymi ze względu na problemy z zabezpieczeniem danych podawanych do tej funkcji<ref name="phpcreatfun">{{Cytuj |tytuł = PHP: create_function - Manual |data dostępu = 2024-10-08 |opublikowany = www.php.net |url = https://www.php.net/manual/en/function.create-function.php |język = en}}</ref>.

Innym problem jest to, że każde wywołanie <code>create_function</code> stworzy nową, globalną funkcję, która będzie istnieć aż do końca programu, i nie może być usunięta przy pomocu „[[Odśmiecanie pamięci|garbage collectora]]”<ref name="phpcreatfun2">{{Cytuj |tytuł = PHP: create_function - Manual |data dostępu = 2024-10-08 |opublikowany = www.php.net |url = https://www.php.net/manual/en/function.create-function.php |język = en}}</ref>. Jeśli ktoś używa tej techniki ponad miarę (np. w pętli), może spowodować nieodwracalne zajęcie pamięci programu.

==== PHP 5.3 ====
W PHP 5.3 dodano nową klasę, zwaną <code>Closure</code> i magiczną metodę <code>__invoke()</code>, która sprawia, że instancja klasy jest wywoływana<ref>{{Cytuj | url=https://archive.is/20121220155035/http://wiki.php.net/rfc/closures | tytuł=PHP: rfc:closures<!-- Tytuł wygenerowany przez bota --> | opublikowany=wiki.php.net | data dostępu=2019-04-07}}</ref>.<syntaxhighlight lang="php">
$x = 3;
$func = function($z) { return $z *= 2; };
echo $func($x); // wypisuje 6
</syntaxhighlight>

W tym przykładzie, <code>$func</code> jest instancją <code>Closure</code>, a <code>echo $func()</code> jest odpowiednikiem <code>$func->__invoke($z)</code>. PHP 5.3 naśladuje funkcje anonimowe, ale on nie obsługuje prawdziwych funkcji anonimowych, ponieważ funkcje w PHP wciąż nie są obiektami pierwszego rzędu.

Z PHP 5.3 obsługuje domknięcia, ale zmienne muszą być wyraźnie oznaczane jako takowe:<syntaxhighlight lang="php">
$x = 3;
$func = function() use(&$x) { $x *= 2; };
$func();
echo $x; // wypisuje 6
</syntaxhighlight>

Zmienna <code>$x</code> jest powiązana za pomocą referencji, a więc wywołanie <code>$func</code> modyfikuje ją tak, że zmiany są widoczne poza samą funkcją.

=== Dialekty języka Prolog ===
==== Logtalk ====
Logtalk używa następującej składni dla predykatów anonimowych (wyrażeń lambda):<syntaxhighlight lang="logtalk">
{FreeVar1, FreeVar2, ...}/[LambdaParameter1, LambdaParameter2, ...]>>Goal
</syntaxhighlight>

Prosty przykład bez wolnych zmiennych i z użyciem predykatu mapującego listy:<syntaxhighlight lang="logtalk">
| ?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
Ys = [2,4,6]
yes
</syntaxhighlight>

[[Currying]] również jest wspierany. Powyższy przykład może być zapisany jako:<syntaxhighlight lang="logtalk">
| ?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
Ys = [2,4,6]
yes
</syntaxhighlight>

==== Visual Prolog ====
Funkcje anonimowe (generalnie rzecz biorąc anonimowe ''predykaty'') zostały wprowadzone w ramach [[Turbo Prolog|Prologu]] 7.2.<ref>[http://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms#Anonymous_Predicates "Anonymous Predicates"]. in Visual Prolog Language Reference</ref> Anonimowe predykaty może pobierać wartości z kontekstu. Jeśli obiekt został stworzony w składowej obiektu może również uzyskać dostęp do stanu obiektu (poprzez pobieranie <code>This</code>).

<code>mkAdder</code> zwraca anonimową funkcję, która pobrała argument <code>x</code> z domknięcia. Zwracana funkcja to funkcja, która dodaje <code>x</code> do jej argumentu:<syntaxhighlight lang="prolog">
clauses
    mkAdder(X) = { (Y) = X+Y }.
</syntaxhighlight>

=== Python ===
[[Python]] obsługuje proste funkcje anonimowe w postaci form Lambda. Wykonywalne ciało lambdy musi być wyrażeniem i nie może być pełną instrukcją, które jest ograniczeniem, która ogranicza jego użyteczność. Wartość zwracana za pomocą wyrażenia lambda jest wartością zawartego w niej wyrażenia. Formy lambda mogą być używane wszędzie tam, gdzie zwykłe funkcje, jednak ograniczenia te sprawiają, że będą to bardzo ograniczona wersja normalnej funkcji. Oto przykład:<syntaxhighlight lang="python">
>>> foo = lambda x: x*x
>>> print(foo(10))
100
</syntaxhighlight>

W zasadzie, konwencja Pythona, podobnie jak ma to miejsce w innych językach, zachęca do korzystania z nazwanych funkcji zdefiniowanych w tym samym zasięgu. Jest to dopuszczalne, gdyż funkcje zdefiniowane lokalnie implementują pełnie funkcjonalności [[Domknięcie (programowanie)|domknięć]], a Pythonie są prawie tak samo wydajne jak lambdy. Można powiedzieć, że w poniższy przykładzie wbudowana funkcja potęgowania poddana została technice [[Currying|curry]]:<syntaxhighlight lang="python">
>>> def make_pow(n):
... def fixed_exponent_pow(x):
... return pow(x, n)
... return fixed_exponent_pow
...
>>> sqr = make_pow(2)
>>> print (sqr(10))
100
>>> cub = make_pow(3)
>>> print (cub(10))
1000
</syntaxhighlight>

=== R ===
W [[R (język programowania)|GNU R]] funkcje anonimowe są definiowane z użyciem składni <code>function(argument-list)expression</code>.<syntaxhighlight lang="r">
> f <- function(x)x*x; f(8)
[1] 64
> (function(x,y)x+y)(5,6)
[1] 11
</syntaxhighlight>

=== Ruby ===
Rubin obsługuje funkcje anonimowe za pomocą struktury składniowej, zwanej ''blokiem''. Istnieją dwa typy danych dla bloków. <code>Proc</code> zachowują się podobnie do [[Domknięcie (programowanie)|domknięć]], a <code>lambda</code> zachowują się bardziej jak funkcje anonimowa<ref>Sosinski, Robert (2008-12-21).</ref>. Blok przekazywany do metody może w pewnych sytuacjach być konwertowany do postaci Proc.<syntaxhighlight lang="ruby">
irb(main):001:0> # Przyklad 1:
irb(main):002:0* # Funkcja w pelni anonimowa z uzyciem bloku.
irb(main):003:0* ex = [16.2, 24.1, 48.3, 32.4, 8.5]
=> [16.2, 24.1, 48.3, 32.4, 8.5]
irb(main):004:0> ex.sort_by { |x| x - x.to_i } # Sortuj po czesci ulamkowej, ignoruj czesc calkowita.
=> [24.1, 16.2, 48.3, 32.4, 8.5]
irb(main):005:0> # Przyklad 2:
irb(main):006:0* # Funkcje pierwszego rzedu jako jednoznaczny obiekt klasy proc
irb(main):007:0* ex = Proc.new { puts "Hello, world!" }
=> #
irb(main):008:0> ex.call
Hello, world!
=> nil
irb(main):009:0> # Przyklad 3:
irb(main):010:0* # Funkcja, ktora zwraca funkcje lambda z parametrami
irb(main):011:0* def is_multiple_of(n)
irb(main):012:1> lambda{|x| x % n == 0}
irb(main):013:1> end
=> nil
irb(main):014:0> multiple_four = is_multiple_of(4)
=> #
irb(main):015:0> multiple_four.call(16)
=> true
irb(main):016:0> multiple_four[15]
=> false
</syntaxhighlight>

=== Scala ===
W [[Scala (język programowania)|Scala]], funkcje anonimowe wykorzystują następującą składnię:<ref>{{Cytuj stronę |url=http://www.scala-lang.org/node/133 |tytuł=Zarchiwizowana kopia |data dostępu=2016-02-10 |archiwum=https://web.archive.org/web/20130723023605/http://www.scala-lang.org/node/133 |zarchiwizowano=2013-07-23}}</ref><syntaxhighlight lang="scala">
 (x: Int, y: Int) => x + y
</syntaxhighlight>

W pewnych kontekstach, na przykład gdy funkcja anonimowa jest parametrem przekazywanym do innej funkcji, kompilator może przewidzieć typy parametrów funkcji anonimowej i mogą być one pominięte w składni. W takich sytuacjach można również użyć wersji skrótowej dla funkcji anonimowych z użyciem znaku podkreślenia, wprowadzając w ten sposób nienazwane parametry.<syntaxhighlight lang="scala">
 val list = List(1, 2, 3, 4)
 list.reduceLeft( (x, y) => x + y )
// Tutaj kompilator potrafi dojsc do typow x i y : Int, Int
// Tak wiec, nie wymagane sa adnotacje parametrow funkcji anonimowych

 list.reduceLeft( _ + _ )
// Podkreslenie oznacza nowy, nienazwany parametr funkcji anonimowej
// To prowadzi do nawet prostszego ekwiwalentu funkcji anonimowej powyzej
</syntaxhighlight>

=== Smalltalk ===
W [[Smalltalk|języku Smalltalk]] anonimowe funkcje nazywane są [[Smalltalk|blokami]]<syntaxhighlight lang="smalltalk">
[ :x | x*x ] value: 4
„zwraca 16”
</syntaxhighlight>

=== Swift ===
W [[Swift (język programowania LLVM)|Swift]], funkcje anonimowe nazywane są domknięciami<ref>{{Cytuj | url=https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/Closures.html | tytuł=The Swift Programming Language (Swift 4): Closures<!-- Tytuł wygenerowany przez bota --> | opublikowany=developer.apple.com | język=en | data dostępu=2017-11-18}}</ref>. Składnia ma następującą formę:<syntaxhighlight lang="swift">
{ (parameters) -> returnType in
  statement
}
</syntaxhighlight>

Na przykład:<syntaxhighlight lang="swift">
{ (s1: String, s2: String) -> Bool in
  return s1 > s2
}
</syntaxhighlight>

Dla zwięzłości i ekspresywności, jeśli typy parametrów oraz typ wartości zwracanej da się wywnioskować w czasie kompilacji to mogą one być pominięte:<syntaxhighlight lang="swift">
{ s1, s2 in return s1 > s2 }
</syntaxhighlight>

Podobnie, Swift obsługuje również niejawne instrukcje return dla domknięć z jedną instrukcją:<syntaxhighlight lang="swift">
{ s1, s2 in s1 > s2 }
</syntaxhighlight>

Wreszcie, nazwy parametrów mogą być również pominięte. W takim przypadku można się do nich odnosić za pomocą tzw. skrótowych nazw argumentów, składających się z symbolu $, oraz ich pozycji (na przykład, $0, $1, $2 itd.):<syntaxhighlight lang="swift">
{ $0 > $1 }
</syntaxhighlight>

=== TCL ===
W [[Tcl (język programowania)|Tcl]], zastosowanie funkcji anonimowej do podniesienia liczby 2 do kwadratu wygląda następująco:<ref>[http://www.tcl.tk/man/tcl8.5/TclCmd/apply.htm ''apply manual page''], retrieved 2012-09-06.</ref><syntaxhighlight lang="tcl">
apply {x {expr {$x*$x}}} 2
# zwraca 4
</syntaxhighlight>

Należy zauważyć, że w tym przykładzie biorą udział dwie „potencjalne funkcje” języka TCL. Najbardziej uniwersalny jest sposób o nazwie ''przedrostka polecenia'' (ang. {{K|en|command prefix}}), i jeśli zmienna ''f ''przechowuje taką funkcję, wtedy wywołanie funkcji ''f(x)'' będzie wyglądało następująco:<syntaxhighlight lang="tcl">
{*}$f $x
</syntaxhighlight>

gdzie <code>{*}</code> - to prefiks rozszerzenia (nowość w TCL 8.5). Prefiks polecenia w powyższym przykładzie to <code>apply {x {x {expr {$x*$x<nowiki>}}}</nowiki></code>. Nazwy poleceń mogą być powiązane z prefiksami z użyciem polecenia <code>interp alias</code>. Prefiksy poleceń obsługują [[currying]]. Prefiksy poleceń są bardzo powszechne w [[Application Programming Interface|API]] TCL.

Inny kandydat na „funkcję” w TCL bywa zwykle nazywany „''lambda''”, i jest obecny w powyższym przykładzie jako <code>{x {expr {$x*$x<nowiki>}}}</nowiki></code>. To ta część pobiera skompilowaną postać funkcji anonimowej, jednak może ona być wywołana tylko za pomocą przekazania polecenia <code>apply</code>. Wyrażenia lambda nie wspierają currying'u, chyba że w połączeniu z <code>apply</code>, aby utworzyć prefiks wyrażenia. Lambda rzadko bywają częścią API TCL.

=== Visual Basic .NET ===
[[Visual Basic .NET|Visual Basic.NET 2008]] wprowadził funkcje anonimowe w postaci wyrażeń lambda. W połączeniu z niejednoznacznym modelem kodowania, VB zapewnia ekonomiczną składnie funkcji anonimowych. Jak w Pythonie, w VB.NET, funkcje anonimowe powinny być definiowane w jednej linii; nie mogą one być złożonymi instrukcjami. Ponadto funkcje anonimowe w VB.NET muszą być typu „<code>Function</code>” - muszą zwracać wartość. <syntaxhighlight lang="vbnet">
Dim foo = Function(x) x * x
Console.WriteLine(foo(10))
</syntaxhighlight>

Visual Basic.NET 2010 dodał wsparcie dla wielowierszowych wyrażeń lambda i funkcji anonimowych, bez wartości zwracanej. Poniżej przykład funkcji do wykorzystania w wątku (<var>Thread</var>).<syntaxhighlight lang="vbnet">
Dim t As New System.Threading.Thread(Sub()
    For n as Integer = 0 to 10   'Licz do 10
        Console.WriteLine(n)     'Wypisuj kazda liczbe
    Next
    End Sub)
t.Start()
</syntaxhighlight>

== Zobacz też ==
* [[funkcje pierwszej klasy]]

== Przypisy ==
{{Przypisy}}

== Linki zewnętrzne ==
* [https://www.deltics.co.nz/blog/posts/48/ Metody Anonimowe - kiedy powinny być stosowane?] (blog o anonimowych funkcjach w Delphi)
* [https://archive.is/20130131085503/http://planetofcoders.com/c-lambda-expressions/ W C# Wyrażenia Lambda] 
* [https://archive.today/2014.01.28-163617/http://www.takipiblog.com/2014/01/16/compiling-lambda-expressions-scala-vs-java-8/ Compiling Lambda Expressions: Scala vs. Java 8]
* [https://archive.today/2015.04.07-204457/http://webwidetutor.com/php/PHP-Anonymous-Functions-?id=12 PHP Anonymous Functions]

[[Kategoria:Typy danych]]
[[Kategoria:Rachunek lambda]]