U programiranju, **anonimna funkcija** je funkcija definisana tako da nije vezana za identifikator. Anonimne funkcije su često:

1. argumenti prosleđeni funkcijama višeg reda, ili
2. se koriste za konstruisanje rezultata funkcije višeg reda koja treba da vrati funkciju.

Ako se funkcija koristi jednom, ili ograničen broj puta, anonimna funkcija može biti sintaksički "lakša" od korišćenja imenovane funkcije. Anonimne funkcije su česte u jezicima funkcionalnog programiranja i jezicima koji podržavaju funkcije prve klase (first-class funkcije), gde ispunjavaju ulogu tipa funkcije kao što literali rade za tipove podataka. 

Anonimne funkcije je uveo Alonzo Čerč kada je otkrio lambda račun 1936. godine, pre nastanka elektronskih računara, kada su sve funkcije bile anonimne. U nekoliko programskih jezika, anonimne funkcije su predstavljene ključnom rečju lambda, i anonimne funkcije se često nazivaju lambdama ili lambda apstrakcijama. Anonimne funkcije su deo programskih jezika još od nastanka programskog jezika Lisp 1958. i sve veći broj modernih programskih jezika podržava anonimne funkcije. Takođe anonimne funkcije se mogu posmatrati kao forma ugnježdenih funkcija.

Upotreba
--------

Anonimne funkcije mogu biti korišćene za funkcionalnost koja ne treba biti imenovana i za kratkotrajnu upotrebu. Neki bitniji primeri su u korišćenju closure i currying funkcija.

Korišćenje anonimnih funkcija je pitanje stila. Njihovo korišćenje nikada nije jedini način za rešavanje problema; Svaka anonimna funkcija može biti definisana imenovanom funkcijom i biti pozivana imenom. Neki programeri koriste anonimne funkcije za pisanje kodova koji se neće izvršavati više puta, a u sebi sadrži veliki broj jednolinijskih funkcija.

U nekim programskim jezicima, anonimne funkcije se često implementiraju za veoma specifične potrebe kao što je korišćenje u obliku callback funkcija, ili instanciranje funkcije za konkretne vrednosti, koje mogu biti efikasnije, čitljivije i manje sklone greškama nego imenovane funkcije.

Kod u sledećim primerima je napisan u jeziku Python 2.x .

### Sortiranje

Kad pokušavamo da sortiramo nestandardnim načinom, korišćenje anonimne funkcije u komparacione svrhe može biti jednostavnije od korišćenja imenovanih funkcija. Većina jezika nudi generičku funkciju koja implementira algoritam za sortiranje koji će sortirati proizvoljne objekte. Ove funkcije obično primaju proizvolju funkciju poređenja koja prima dva proizvoljna objekta i vraća vrednosti manje od 0, 0 ili veće od 0 u odnosu na to da li je drugi prosleđen objekat veći, jednak ili manji od prvog prosleđenog.

Sortiranje liste stringova po njihovoj dužini:

```
>>> a = ['house', 'car', 'bike']
>>> a.sort(lambda x,y: cmp(len(x), len(y)))
>>> print(a)
['car', 'bike', 'house']

```
Anonimna funkcija u ovom primeru je lambda izraz:

```
lambda x,y: cmp(...)

```
Anonimna funkcija prima dva argumenta, x i y, i vraća poređenje između njih koristeći ugrađenu funkciju cmp().

```
>>> a = [10, 'number', 11.2]
>>> a.sort(lambda x,y: cmp(x.\_\_class\_\_.\_\_name\_\_, y.\_\_class\_\_.\_\_name\_\_))
>>> print(a)
[11.2, 10, 'number']

```

### Closure

Closure funkcije su funkcije koje imaju vrednost u okruženju koje sadrži 'bound' promenljive.

Sledeći primer povezuje promenljivu "threshold" sa anonimnom funkcijom koja poredi ulaz sa njom.

```
def comp(threshold):
    return lambda x: x < threshold

```
Ovo može služiti kao generator funkcija poređenja.

```
>>> 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

```
Bilo bi nepraktično kreirati funkciju za svaku funkciju poređenja i može biti nepraktično čuvati vrednost po kojoj se poredi za dalju upotrebu. I pored razloga zašto se closure funkcije koriste, anonimne funkcije su entitet koji sadrži funkcionalnost koja vrši poređenje.

### Currying

Currying je proces promene funkcije da bi bilo potrebno manje ulaznih vrednosti (u ovom slučaju transformacija funkcije koja izvodi deljenje bilo kog celog broja u onu funkciju koja vrši deljenje sa skupom celih brojeva).

```
>>> def divide(x, y):
... return x / y

>>> def divisor(d):
... return lambda x: divide(x, d)

>>> half = divisor(2)
>>> third = divisor(3)

>>> print half(32), third(32)
16 10

>>> print half(40), third(40)
20 13

```
Korišćenje anonimnih funkcija nije česta kod currying tehnike, ali se može koristiti u te svrhe.U primeru iznad, funkcija divisor generiše funkciju sa konkretnim deliteljem.Funkcija half i third izvodi funkciju divide sa fiksiranim deliteljem.

Funkcija divisor takođe primenjuje clousure tehniku tako što vezuje promenljivu "d".

### Funkcije višeg reda

Python 2.x sadrži nekoliko funkcija koje primaju anonimne funkcije kao argument.Ovaj odeljak opisuje njih.

#### Map

Map funkcija vrši poziv funkcije nad svakim elementom liste. Sledeći primer kvadrira svaki element u nizu anonimnom funkcijom.

```
>>> a = [1, 2, 3, 4, 5, 6]
>>> print map(lambda x: x\*x, a)
[1, 4, 9, 16, 25, 36]

```
Anonimna funkcija prima argument i množi ga sobom (kvadrira ga). Po mišljenju kreatora jezika, forma iznad nije preporučljiva, vec predlažu sledeću formu sa istim značenjem a bolje se uklapa sa namenom jezika:

```
>>> a = [1, 2, 3, 4, 5, 6]
>>> print [x\*x for x in a]
[1, 4, 9, 16, 25, 36]

```

#### Filter

Filter funkcija vraća sve elemente liste koje imaju vrednost True kad ih prosledimo određenoj funkciji.

```
>>> a = [1, 2, 3, 4, 5, 6]
>>> print filter(lambda x: x % 2 == 0, a)
[2, 4, 6]

```
Anonimna funkcija proverava da li je prosleđeni argument paran. Isto kao u slučaju sa mapom, kod ispod je preporučljiviji.

```
>>> a = [1, 2, 3, 4, 5, 6]
>>> print [x for x in a if x % 2 == 0]
[2, 4, 6]

```

#### Fold

Fold/reduce funkcija prolazi kroz sve elemente liste (obično s leva na desno), i nagomilava vrednost pri tom prolasku. Česta upotreba ovoga je kombinovanje elemenata liste u jednu vrednost. Na primer:

```
>>> a = [1, 2, 3, 4, 5]
>>> print reduce(lambda x,y: x\*y, a)
120

```
Ovo izvršava sledeće:

{\displaystyle (((1\times 2)\times 3)\times 4)\times 5=120}

Anonimna funkcija ovde je množenje dva argumenta.

Rezultat fold funkcije mora biti jedna vrednost. Umesto toga, i map i filter mogu biti kreirani korišćenjem fold funkcije.U mapi, vrednost koja je nagomilana je zapravo nova lista koja sadrži rezultate primene funkcije na svaki element originalne liste. U filter funkciji, vrednost koja je nagomilana je nova lista koja sadrži samo one elemente koji ispunjavaju određen uslov.

Spisak jezika
-------------

Sledeća lista programskih jezika neimenovane anonimne funkcije podrzava u potpunosti, delom, ili ne podržava.

Ova tabela ukazuje ne neke opšte trendove. Jezici koji ne podržavaju anonimne funkcije(C, Pascal, Object Pascal) su konvencijalni strogo tipizirani jezici. Medjutim, strogo tipizirani jezici mogu podržavati anonimne funkcije.Na primer, ML jezici su strogo tipizirani i sadrže anonimne funkcije, i Delphi, kao dijalekt objektnog Pascal-a je nadograđen tako da podržava anonimne funkcije.Takođe, jezici koji tretiraju funkcije kao 'funkcije prvog reda'(Dylan, Haskell, JavaScript,Lisp,ML, Perl,Python, Ruby,Scheme) sadrže anonimne funkcije tako da mogu biti definisane i prosleđene jednostavno kao i tipovi podataka. Međutim, novi C++11 standard ih dodaje C++-u iako je konvencijalan, strogo tipiziran jezik.

  


| Language | Support | Notes |
| --- | --- | --- |
| ActionScript | Šablon:Y |  |
| Ada | Šablon:N | 'Expression' funkcije su deo jezika Ada2012 |
| ALGOL 68 | Šablon:Y |  |
| Brainfuck | Šablon:N |  |
| Bash | Šablon:Partial | Biblioteka je napravljena tako da sadrži anonimne funkcije u jeziku Bash. |
| C | Šablon:N | Podrška je omogućena u Clang-u zajedno sa LLVM comiler-rt bibliotekom. GCC podrška je data za makro implementaciju koja omogućava upotrebu. Detalje videti ispod. |
| C#] | Šablon:Y |  |
| C++ | Šablon:Y | Podrška postoji od C++11 standarda. |
| CFML | Šablon:Y | Podrška postoji od Railo 4 ColdFusion 10. |
| Clojure | Šablon:Y |  |
| COBOL | Šablon:N | Micro Focus-ov nestandardni Managed COBOL dijalekt podržava lambde, koje se nazivaju anonimnim metodama. |
| Curl | Šablon:Y |  |
| D | Šablon:Y |  |
| Dart | Šablon:Y |  |
| Delphi | Šablon:Y |  |
| Dylan | Šablon:Y |  |
| Eiffel | Šablon:Y |  |
| Elixir | Šablon:Y |  |
| Erlang | Šablon:Y |  |
| F# | Šablon:Y |  |
| Factor | Šablon:Y | "Quotations" podržava ovo. |
| Fortran | Šablon:N |  |
| Frink | Šablon:Y |  |
| Go | Šablon:Y |  |
| Gosu | Šablon:Y |  |
| Groovy | Šablon:Y |  |
| Haskell | Šablon:Y |  |
| Haxe | Šablon:Y |  |
| Java | Šablon:Y | Podržano u Java 8. videti Java ograničenja ispod za detalje. |
| JavaScript | Šablon:Y |  |
| Julia | Šablon:Y |  |
| Lisp | Šablon:Y |  |
| Logtalk | Šablon:Y |  |
| Lua | Šablon:Y |  |
| MUMPS | Šablon:N |  |
| Mathematica | Šablon:Y |  |
| Maple | Šablon:Y |  |
| MATLAB | Šablon:Y |  |
| Maxima | Šablon:Y |  |
| OCaml | Šablon:Y |  |
| Octave | Šablon:Y |  |
| Object Pascal | Šablon:Partial | Delfi, dijalekt Objektnog paskala podržava anonimne funkcije još od Delphi-ja 2009. Oxygene Object Pascal dijalekt ih takođe podržava. |
| Objective-C (Mac OS X 10.6+) | Šablon:Y |  |
| Pascal | Šablon:N |  |
| Perl | Šablon:Y |  |
| PHP | Šablon:Y | Od verzije PHP 5.3.0 prave anonimne funkcije su podržane. Pre toga, bile su podržane samo delom, koji je radio slično kao C#-ova imprementacija. |
| PL/I | Šablon:N |  |
| Python | Šablon:Partial | Python podržava anonimne funkcije kroz lambda sintaksu, koja podržava samo izraze, ne naredbe. |
| R | Šablon:Y |  |
| Racket | Šablon:Y |  |
| Rexx | Šablon:N |  |
| RPG | Šablon:N |  |
| Ruby | Šablon:Y | Ruby-jeve anonimne funkcije su nasleđene od Smalltalk-a, nazivaju se 'blokovi'. |
| Rust | Šablon:Y |  |
| Scala | Šablon:Y |  |
| Scheme | Šablon:Y |  |
| Smalltalk | Šablon:Y | Smalltalk-ove anonimne funkcije nazivaju se 'blokovi'. |
| Standard ML | Šablon:Y |  |
| Swift | Šablon:Y | Swift-ove anonimne funkcije se nazivaju 'Closures'. |
| TypeScript | Šablon:Y |  |
| Tcl | Šablon:Y |  |
| Vala | Šablon:Y |  |
| Visual Basic .NET v9 | Šablon:Y |  |
| Visual Prolog v 7.2 | Šablon:Y |  |
| Wolfram Language | Šablon:Y |  |

Literatura
----------

* Fernandez, Maribel (2009). *Models of Computation: An Introduction to Computability Theory*. Springer Science & Business Media. str. 33. ISBN 978-1-84882-434-8.