Lambda jest rodzajem funkcji zdefiniowanej w linii. Wraz z lambda zwykle masz jakiś rodzaj zmiennej, która może zawierać odniesienie do funkcji, lambda lub w inny sposób.

Na przykład, oto fragment kodu C#, który nie używa lambda:

public Int32 Add(Int32 a, Int32 b)
{
    return a + b;
}

public Int32 Sub(Int32 a, Int32 b)
{
    return a - b;
}

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, Add);
    Calculator(10, 23, Sub);
}

To wywołuje Kalkulator, przekazując nie tylko dwie liczby, ale jaką metodę wywołać wewnątrz kalkulatora, aby uzyskać wyniki obliczeń.

W C# 2.0 mamy anonimowe metody, które skracają powyższe kod do:

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a + b;
    });
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a - b;
    });
}

A potem w C# 3.0 mamy lambda co czyni kod jeszcze krótszym:

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, (a, b) => a + b);
    Calculator(10, 23, (a, b) => a - b);
}

Odnosi się do rachunku lambda , który jest formalnym systemem, który po prostu ma wyrażenia lambda, które reprezentują funkcję, która przyjmuje funkcję za swój jedyny argument i zwraca funkcję. Wszystkie funkcje w rachunku lambda są tego typu, tj. λ : λ → λ.

Lisp użył koncepcji lambda do nazwania swoich anonimowych literałów funkcji. Lambda reprezentuje funkcję, która pobiera dwa argumenty, x i y i zwraca ich iloczyn:

(lambda (x y) (* x y)) 

Może być stosowany w linii jak to (ocenia do 50):

((lambda (x y) (* x y)) 5 10)

Nazwa "lambda" jest tylko historycznym artefaktem. Mówimy tylko o wyrażeniu, którego wartością jest funkcja.

Prosty przykład (używając Scali do następnego wiersza) to:

args.foreach(arg => println(arg))

Gdzie argument metody foreach jest wyrażeniem funkcji anonimowej. Powyższy wiersz jest mniej więcej taki sam jak napisanie czegoś takiego (nie do końca prawdziwy kod, ale wpadniesz na pomysł): {]}

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

Poza tym, że nie musisz się przejmować:

1. deklarowanie funkcja gdzie indziej (i trzeba jej szukać, gdy ponownie w kodzie później).
2. nazwanie czegoś, czego używasz tylko raz.

Gdy już przyzwyczaisz się do funkcji wartości, obejście się bez nich wydaje się tak głupie, jak konieczność nazywania każdego wyrażenia, na przykład:

int tempVar = 2 * a + b
...
println(tempVar)

Zamiast pisać wyrażenie tam, gdzie jest potrzebne:

println(2 * a + b)

Dokładna notacja różni się w zależności od języka; Grecki nie zawsze jest wymagany! ;-)

Rachunek lambda jest spójną matematyczną teorią podstawienia. W matematyce szkolnej widzimy na przykład x+y=5 sparowane z x−y=1. Wraz ze sposobami manipulowania poszczególnych równań jest również możliwe, aby umieścić informacje z tych dwóch razem, pod warunkiem cross-równania podstawienia są wykonane logicznie. Rachunek Lambda kodyfikuje prawidłowy sposób wykonywania tych podstawień.

Biorąc pod uwagę, że y = x−1 jest poprawnym przegrupowaniem drugiego równania, to: λ y = x−1 oznacza funkcja zastępująca symbole {[6] } dla symbolu y. Teraz wyobraź sobie zastosowanie λ y do każdego terminu w pierwszym równaniu. Jeśli termin jest y, wykonaj zastąpienie; w przeciwnym razie nic nie rób. Jeśli zrobisz to na papierze, zobaczysz, jak zastosowanie λ y sprawi, że pierwsze równanie będzie rozwiązywalne.

To odpowiedź bez żadnej informatyki czy programowania.

Najprostszy przykład programowania, jaki przychodzi mi do głowy, pochodzi z http://en.wikipedia.org/wiki/Joy_ (programming_language)#How_it_works :

Oto jak funkcja kwadratowa może być zdefiniowana w imperatywie język programowania (C):

int square(int x)
{
    return x * x;
}

Zmienna x jest parametrem formalnym, który jest zastępowany przez rzeczywistą wartość do kwadratu podczas wywoływania funkcji. W funkcjonalnym język (schemat) ta sama funkcja byłaby zdefiniowana:

(define square
  (lambda (x) 
    (* x x)))

Jest to pod wieloma względami inne, ale nadal używa formalnego parametr x w ten sam sposób.

Dodano: http://imgur.com/a/XBHub

Nieco uproszczone: funkcja lambda to taka, która może być przekazywana do innych funkcji i jest dostępna logicznie.

W C# składnia lambda jest często kompilowana do prostych metod w taki sam sposób jak anonimowe delegaty, ale może być również rozkładana i odczytywana z logiki.

Na przykład (w C#3):

LinqToSqlContext.Where( 
    row => row.FieldName > 15 );

LinqToSql może odczytać tę funkcję (x > 15) i przekonwertować ją na rzeczywisty SQL do wykonania za pomocą drzew wyrażeń.

Powyższe stwierdzenie staje się:

select ... from [tablename] 
where [FieldName] > 15      --this line was 'read' from the lambda function

Różni się to od zwykłych metod lub anonimowych delegatów (które tak naprawdę są tylko magią kompilatora), ponieważ nie można ich odczytać .

Nie wszystkie metody w C#, które używają składni lambda, mogą być kompilowane do drzew wyrażeń (np. rzeczywistych funkcji lambda). Na przykład:

LinqToSqlContext.Where( 
    row => SomeComplexCheck( row.FieldName ) );

Teraz nie można odczytać drzewa wyrażeń-SomeComplexCheck nie może być rozbity. Polecenie SQL zostanie wykonane bez where, a każdy wiersz danych zostanie umieszczony przez SomeComplexCheck.

Funkcji Lambda nie należy mylić z metodami anonimowymi. Na przykład:

LinqToSqlContext.Where( 
    delegate ( DataRow row ) { 
        return row.FieldName > 15; 
    } );

To również ma funkcję 'inline', ale tym razem jest to tylko magia kompilatora - kompilator C# podzieli to na nową metodę instancji z autogenerowaną nazwą.

Anonimowe metody nie mogą być odczytywane, a więc logika nie może być przetłumaczona tak jak dla funkcji lambda.

Podoba mi się Wyjaśnienie Lambda w tym artykule: Ewolucja LINQ i jej wpływ na projektowanie C # . Miało to dla mnie wiele sensu, ponieważ pokazuje prawdziwy świat dla Lambda i buduje go jako praktyczny przykład.

Ich szybkie wyjaśnienie: lambda są sposobem na traktowanie kodu (funkcji) jako danych.

Przykład lambda w Rubim jest następujący:

hello = lambda do
    puts('Hello')
    puts('I am inside a proc')
end

hello.call

Generuje następujące Wyjście:

Hello
I am inside a proc

@Brian używam lambda cały czas w C#, w operatorach LINQ i non-LINQ. Przykład:

string[] GetCustomerNames(IEnumerable<Customer> customers)
 { return customers.Select(c=>c.Name);
 }

Przed C#, używałem funkcji anonimowych w JavaScript do wywoływania zwrotów do funkcji AJAX, zanim termin Ajax został nawet ukuty:

getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});

Ciekawostką ze składni lambda C#jest to, że sam ich Typ nie może być inferowany (np. nie można wpisać var foo = (x, y) = > x * y), ale w zależności od tego, do jakiego typu są przypisane, będą kompilowane jako delegaty lub abstrakcyjne drzewa składni reprezentujące wyrażenie (w ten sposób MAPERZY obiektów LINQ wykonują swoją "zintegrowaną z językiem" magię).

Lambda w Lispie mogą być również przekazywane do operatora cudzysłowu, a następnie przemierzane jako lista list. Niektóre potężne makra są tworzone w ten sposób.

Pytanie jest formalnie bardzo dobrze wyjaśnione, więc nie będę się starał dodawać więcej na ten temat.

W bardzo prostych, nieformalnych słowach do kogoś, kto wie bardzo mało lub nic na temat matematyki lub programowania, wyjaśniłbym to jako małą "maszynę" lub "pudełko", która pobiera pewne dane wejściowe, wykonuje pewne prace i produkuje pewne dane wyjściowe, nie ma konkretnej nazwy, ale wiemy, gdzie to jest i dzięki tej wiedzy, używamy go.

Praktycznie rzecz biorąc, dla osoby, która wie, co to jest funkcja, chciałbym powiedz im, że jest to funkcja, która nie ma nazwy, zwykle umieszczana w pamięci, która może być używana tylko przez odwołanie się do tej pamięci (zwykle za pomocą zmiennej-jeśli słyszeli o koncepcji wskaźników funkcji, użyłbym ich jako podobnej koncepcji) - ta odpowiedź obejmuje ładne podstawy (nie wspominając o zamknięciach itp.), ale można uzyskać punkt łatwo.

Możesz myśleć o niej jako o funkcji anonimowej-oto kilka dodatkowych informacji: Wikipedia-funkcja anonimowa

Tylko dlatego, że nie mogę zobaczyć przykładu C++11 tutaj, pójdę dalej i wrzucę ten ładny przykład z tutaj . Po przeszukaniu jest to najczystszy przykład specyficzny dla języka, jaki mogłem znaleźć.

Hello, Lambdas, version 1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

Witaj, Lambda, Wersja 2:

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}

Mam problem z objęciem głowy wyrażeniami lambda, ponieważ pracuję w Visual FoxPro, który ma podstawienie makra i funkcje ExecScript{} i Evaluate (), które zdają się służyć temu samemu celowi.

? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");

FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)

Jedną z zalet używania formalnych lambd jest (zakładam) sprawdzanie w czasie kompilacji: Fox nie będzie wiedział, czy wpisujesz powyższy ciąg tekstowy, dopóki nie spróbuje go uruchomić.

Jest to również przydatne dla kodu opartego na danych: możesz przechowywać całe procedury w polach memo w bazy danych, a następnie po prostu ocenić je w czasie wykonywania. Pozwala to dostosować część aplikacji bez faktycznego dostępu do źródła. (Ale to zupełnie inny temat.)

Dla osoby bez doświadczenia comp-sci, czym jest lambda w świecie informatyki?

Zilustruję to intuicyjnie krok po kroku prostymi i czytelnymi kodami Pythona.

W skrócie, lambda jest tylko anonimową funkcją inline.

Zacznijmy od zadania, aby zrozumieć lambdas jako pierwszoroczniak z podstawową arytmetyką.

Schemat przypisania to 'nazwa = wartość', patrz:

In [1]: x = 1
   ...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'

"x", "y" to nazwy, a 1, "value" to wartości. Wypróbuj funkcję w matematyce

In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined

Raporty o błędach,
nie można pisać matematyki bezpośrednio jako kodu, " n " powinno być zdefiniowane lub przypisane do wartości.

In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396

To działa teraz, co jeśli nalegasz na połączenie dwóch oddzielnych linii w jedną. Nadchodzi lambda

In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>

Nie zgłoszono żadnych błędów.

To jest rzut oka na lambda, pozwala na zapisanie funkcji w jednej linii, tak jak w matematyce do komputera bezpośrednio.

Zobaczymy to później.

Kontynuujmy kopanie głębiej na "przypisanie".

Jak pokazano powyżej, symbol równości = Działa dla prostego typu danych (1 i 'wartość') i prostego wyrażenia (n**2 + 2*n + 1).

Spróbuj tego:

In [15]: x = print('This is a x')
This is a x
In [16]: x
In [17]: x = input('Enter a x: ')
Enter a x: x

Działa dla prostych instrukcji,jest ich 11 typów w Pythonie 7. Proste instrukcje-dokumentacja Pythona 3.6.3

A co z wyrażeniem złożonym,

In [18]: m = n**2 + 2*n + 1 if n > 0
SyntaxError: invalid syntax
#or
In [19]: m = n**2 + 2*n + 1, if n > 0
SyntaxError: invalid syntax

Nadchodzi def enable it working

In [23]: def m(n):
    ...:     if n > 0:
    ...:         return n**2 + 2*n + 1
    ...:
In [24]: m(2)
Out[24]: 9

Tada, analizuj to, ' m 'to nazwa,' n**2 + 2*n + 1 ' jest wartością.: jest odmianą'='.
Znajdź to, jeśli tylko dla zrozumienia, wszystko zaczyna się od zadania i wszystko jest zadaniem.

Teraz wróć do lambda, Mamy funkcję o nazwie " m "

Spróbuj:

In [28]: m = m(3)
In [29]: m
Out[29]: 16

Są tu dwie nazwy "m", funkcja m ma już nazwę, zduplikowaną.

Formatuje się tak:

In [27]: m = def m(n):
    ...:         if n > 0:
    ...:             return n**2 + 2*n + 1
    SyntaxError: invalid syntax

It ' s not a smart strategia, więc raporty błędów

Musimy usunąć jedną z nich, ustawić funkcję bez nazwy.

m = lambda n:n**2 + 2*n + 1

Nazywa się to "funkcją anonimową"

Podsumowując,

1. lambda w funkcji inline, która umożliwia zapisanie funkcji w jednej linii prostej, jak to ma miejsce w matematyce
2. lambda jest anonimowy

Jest to funkcja, która nie ma nazwy. Dla np. w c# można użyć

numberCollection.GetMatchingItems<int>(number => number > 5);

Aby zwrócić liczby większe niż 5.

number => number > 5

Jest częścią lambda tutaj. Reprezentuje funkcję, która pobiera parametr (numer ) i zwraca wartość logiczną (liczba > 5). Metoda GetMatchingItems używa tej metody lambda na wszystkich elementach w kolekcji i zwraca pasujące elementy.

Ja też mam. Próbowałem w JS z tym:

var addAndMult = function(x) {
        return (function(y) {
            return (function(z) {
                return (x+y)*z; 
                });
            });
        };

Dodaje 2 do 4, a następnie multiplikuje wynik o 6. Jednak czasami trudno mi to odczytać: (

Również zrobiłem ciekawą funkcję forEach:

var forEach = function(arr) {
            return (function(x) {
            for (var i=0; arr[i]; i++) {
                 x(arr[i]);
             }
        });
    }

ForEach([1,2,3,4,5])(console.log);

Ta metoda będzie iteracją tablicy i wykona akcję-w przypadku drukowania na konsoli. Teraz też rozumiem, dlaczego labmda są potężne.

W Javascript, na przykład, funkcje są traktowane jako ten sam typ mieszany, jak Wszystko inne (int, string, float, bool). W związku z tym możesz tworzyć funkcje w locie, przypisywać je do rzeczy i oddzwonić później. Jest to przydatne, ale nie coś, co chcesz nadużywać, bo zdezorientujesz wszystkich, którzy muszą utrzymywać twój kod po tobie...

To jest jakiś kod, którym bawiłem się, aby zobaczyć, jak głęboka jest ta królicza Nora:

var x = new Object;
x.thingy = new Array();
x.thingy[0] = function(){ return function(){ return function(){ alert('index 0 pressed'); }; }; }
x.thingy[1] = function(){ return function(){ return function(){ alert('index 1 pressed'); }; }; }
x.thingy[2] = function(){ return function(){ return function(){ alert('index 2 pressed'); }; }; }

for(var i=0 ;i<3; i++)
    x.thingy[i]()()();

W kontekście CS funkcja lambda jest abstrakcyjnym pojęciem matematycznym, które zajmuje się problemem symbolicznej oceny wyrażeń matematycznych. W tym kontekście funkcja lambda jest taka sama jak termin lambda.

Ale w językach programowania to coś innego. To fragment kodu, który jest zadeklarowany jako " na miejscu "i który można przekazać jako"obywatel pierwszej klasy". Koncepcja ta okazała się przydatna tak, że weszła do prawie wszystkich popularnych nowoczesnych programów języki (patrz funkcje lambda everwhere post).

W programowaniu komputerowym lambda jest fragmentem kodu (wypowiedzeniem, wyrażeniem lub ich grupą), który pobiera pewne argumenty z zewnętrznego źródła. Nie zawsze musi to być funkcja anonimowa - mamy wiele sposobów na ich realizację.

Mamy wyraźny rozdział między wyrażeniami, twierdzeniami i funkcjami, których matematycy nie mają.

Słowo" funkcja "w programowaniu jest również inne - mamy" function is a series of steps to do " (z łac. "wykonać"). W matematyce chodzi o korelację między zmiennymi.

Języki funkcyjne starają się być jak najbardziej podobne do formuł matematycznych, a ich słowa znaczą prawie to samo. Ale w innych językach programowania mamy to inaczej.

Pytanie zostało w pełni wyjaśnione, nie chcę wchodzić w szczegóły. Chcę podzielić się korzyściami przy pisaniu obliczeń numerycznych w rust.

Istnieje przykład lambda (funkcja anonimowa)

let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };

Wyjście jako po

println!("f={:.6}      df={:.6}", f(10.0), df(10.0))

f=98.000000       df=20.000000

Wyobraź sobie, że masz restaurację z opcją dostawy i masz zamówienie, które musi być wykonane w mniej niż 30 minut. Chodzi o to, że klienci zwykle nie dbają o to, czy wysyłasz jedzenie rowerem samochodem lub boso, o ile utrzymasz posiłek w cieple i związany. Przekonwertujmy ten idiom na Javascript z anonimowymi i zdefiniowanymi funkcjami transportowymi.

Poniżej zdefiniowaliśmy sposób naszego dostarczania aka definiujemy nazwę funkcji:

// ES5 
var food = function withBike(kebap, coke) {
return (kebap + coke); 
};

Co by było gdybyśmy użyli funkcje arrow / lambda do wykonania tego transferu:

// ES6    
const food = (kebap, coke) => { return kebap + coke };

Btw, nie polecam Kebap z koksem dlatego górne kody dadzą błędy. Baw się dobrze.