Was ist der Unterschied zwischen einer Funktion und einem Lambda?

Ich bin ein bisschen verwirrt über "Funktion" und "Lambda". Ich habe einige Beispiele gesehen, die zeigen, dass das Schema-Schlüsselwort lambdadem JavaScript-Schlüsselwort sehr ähnlich ist function, aber ich weiß wirklich nicht, wie sie zusammenhängen.

Mir wurde gesagt, dass 'function' und 'method' synonym verwendet werden können, wenn über Objekte in .net gesprochen wird. Ich frage mich, ob 'Lambda' und 'Funktion' dasselbe bedeuten. Ich frage mich, ob 'Lambda' eine esoterische Bedeutung hat, da der griechische Buchstabe Lambda (λ) in so vielen Avataren auf dieser Seite vorkommt. Um die Dinge in .net noch verwirrender zu machen, verweisen die funktionalen Teile von C # auf Funktionsausdrücke, die als 'Lambda-Ausdrücke' an eine andere Funktion übergeben wurden, sodass das Wort tatsächlich überall vorkommt.

Ich bin auch vage mit dem Begriff "Lambda-Kalkül" vertraut.

Was ist der Unterschied zwischen einer Funktion und einem Lambda?

Das Wort "Lambda" oder "Lambda-Ausdrücke" bezieht sich meist auf anonyme Funktionen. In diesem Sinne ist ein Lambda eine Art von Funktion, aber nicht jede Funktion ist ein Lambda (dh benannte Funktionen werden normalerweise nicht als Lambdas bezeichnet). Abhängig von der Sprache werden anonyme Funktionen häufig anders implementiert als benannte Funktionen (insbesondere in Sprachen, in denen anonyme Funktionen abgeschlossen sind und benannte Funktionen nicht). Daher kann es sinnvoll sein, sie mit unterschiedlichen Begriffen zu bezeichnen.

Der Unterschied zwischen dem Lambda-Schlüsselwort des Schemas und dem Funktionsschlüsselwort von Javascript besteht darin, dass das letztere verwendet werden kann, um sowohl anonyme Funktionen als auch benannte Funktionen zu erstellen, während das erstere nur anonyme Funktionen erstellt (und Sie definezum Erstellen benannter Funktionen verwenden würden).

Der Lambda-Kalkül ist eine minimale Programmiersprache / ein mathematisches Rechenmodell, das Funktionen als einzige "Datenstruktur" verwendet. Im Lamdba-Kalkül werden mit dem Lambda-Symbol (anonyme) Funktionen erzeugt. Daher kommt die Verwendung des Begriffs "Lambda" in anderen Sprachen.

Ein Lambda ist einfach eine anonyme Funktion - eine Funktion ohne Namen.

Beantwortet hier: https://stackoverflow.com/questions/16501/what-is-a-lambda-function

Grundsätzlich ist Lambda eine anonyme Funktion.

In C # ist die Funktion Anonymous ein allgemeiner Begriff, der sowohl Lambda-Ausdrücke als auch anonyme Methoden enthält (anonyme Methoden sind Delegate-Instanzen ohne tatsächliche Methodendeklaration).

Lambda-Ausdrücke können in die Ausdrücke Lambda und Statement Lambda zerlegt werden

Ausdruck Lambda:

(int x, string y) => x == y.Length 

Die Anweisung lambda ähnelt dem Ausdruck lambda, mit der Ausnahme, dass die Anweisung (en) in geschweifte Klammern eingeschlossen sind:

(int x, string y) => {
         if (x == y.Length) {
             Console.WriteLine(y);
         }
}

Wenn wir über Lambda-Ausdrücke in JavaScript sprechen, bedeutet das im Grunde nur, eine Funktion als Argument in einem Aufruf einer anderen Funktion zu verwenden.

var calculate = function(x, y, operation){
    return operation(x, y);
}

// we're passing anonymous function as a third argument
calculate(10, 15, function(x, y) {
    return x + y;
}); // 25

TL; DR Wie andere betonten: Die Lambda-Notation ist nur eine Möglichkeit, Funktionen zu definieren, ohne gezwungen zu sein, ihnen einen Namen zu geben.

Lange Version

Ich würde gerne ein bisschen auf dieses Thema eingehen, weil ich es sehr interessant finde. Haftungsausschluss: Ich habe vor langer Zeit meinen Kurs über Lambda-Kalkül belegt. Wenn jemand mit besseren Kenntnissen Ungenauigkeiten in meiner Antwort findet, kann er mir gerne helfen, diese zu verbessern.

Beginnen wir mit Ausdrücken, zB 1 + 2und x + 2. Literale wie 1und 2werden Konstanten genannt, weil sie an bestimmte feste Werte gebunden sind.

Ein Bezeichner wie x" Variable" muss zuerst an einen Wert gebunden werden, um ihn auszuwerten. Sie können also grundsätzlich nicht bewerten x + 1, solange Sie nicht wissen, was xist.

Die Lambda-Notation bietet ein Schema zum Binden bestimmter Eingabewerte an Variablen. Ein Lambda-Ausdruck kann gebildet werden, indem λx .vor einem existierenden Ausdruck hinzugefügt wird , z λx . x + 1. Variable xwird gesagt, dass frei in x + 1und gebunden inλx . x + 1

Wie hilft dies bei der Auswertung von Ausdrücken? Wenn Sie dem Lambda-Ausdruck einen Wert hinzufügen, wie folgt

(λx . x + 1) 2

Dann können Sie den gesamten Ausdruck auswerten, indem Sie alle Vorkommen der Variablen xdurch den Wert 2 ersetzen (binden) :

(λx . x + 1) 2
      2 + 1
      3

Die Lambda-Notation bietet also einen allgemeinen Mechanismus, um Dinge an Variablen zu binden, die in einem Ausdrucks- / Programmblock vorkommen. Je nach Kontext entstehen so in den Programmiersprachen sehr unterschiedliche Konzepte:

• In einer rein funktionalen Sprache wie Haskell stellen Lambda-Ausdrücke Funktionen im mathematischen Sinne dar: Ein Eingabewert wird in den Lambda-Körper injiziert und ein Ausgabewert wird erzeugt.
• In vielen Sprachen (z. B. JavaScript, Python, Schema) kann die Bewertung des Körpers eines Lambda-Ausdrucks Nebenwirkungen haben. In diesem Fall kann man den Begriff Prozedur verwenden , um die Differenz für reine Funktionen zu kennzeichnen.

Abgesehen von den Unterschieden geht es bei der Lambda-Notation darum, formale Parameter zu definieren und an tatsächliche Parameter zu binden.

Der nächste Schritt besteht darin, einer Funktion / Prozedur einen Namen zu geben. In mehreren Sprachen sind Funktionen Werte wie alle anderen, sodass Sie einer Funktion wie folgt einen Namen geben können:

(define f (lambda (x) (+ x 1)))      ;; Scheme

f = \x -> x + 1                      -- Haskell

val f: (Int => Int) = x => x + 1     // Scala

var f = function(x) { return x + 1 } // JavaScript

f = lambda x: x + 1                  # Python

Wie Eli Barzilay betonte, binden diese Definitionen den Namen nur fan einen Wert, der zufällig eine Funktion ist. In dieser Hinsicht sind Funktionen, Zahlen, Zeichenfolgen und Zeichen alle Werte, die auf die gleiche Weise an Namen gebunden werden können:

(define n 42)   ;; Scheme

n = 42          -- Haskell

val n: Int = 42 // Scala

var n = 42      // JavaScript

n = 42          # Python

In diesen Sprachen können Sie eine Funktion auch unter Verwendung der bekannteren (aber äquivalenten) Notation an einen Namen binden:

(define (f x) (+ x 1))         ;; Scheme

f x = x + 1                    -- Haskell

def f(x: Int): Int = x + 1     // Scala

function f(x) { return x + 1 } // JavaScript

def f(x): return x + 1         # Python

Einige Sprachen, z. B. C, unterstützen nur die letztere Notation zum Definieren von (benannten) Funktionen.

Verschlüsse

Einige abschließende Bemerkungen zu Schließungen . Betrachten Sie den Ausdruck x + y. Dieser enthält zwei freie Variablen. Wenn Sie xmit der Lambda-Notation binden , erhalten Sie:

\x -> x + y

Dies ist (noch) keine Funktion, da sie noch eine freie Variable enthält y. Sie könnten auch eine Funktion daraus machen, indem Sie Folgendes binden y:

\x -> \y -> x + y

oder

\x y -> x + y

Das ist genau das gleiche wie die +Funktion.

Aber Sie können zum Beispiel yauf andere Weise binden (*):

incrementBy y = \x -> x + y

Das Ergebnis der Anwendung von FunktionsinkrementBy auf eine Zahl ist ein Abschluss, dh eine Funktion / Prozedur, deren Hauptteil eine freie Variable (z. B. y) enthält, die an einen Wert aus der Umgebung gebunden wurde, in der der Abschluss definiert wurde.

Ebenso incrementBy 5die Funktion (Closure), die die Zahlen um 5 erhöht.

HINWEIS (*)

Ich betrüge hier ein bisschen:

incrementBy y = \x -> x + y

ist äquivalent zu

incrementBy = \y -> \x -> x + y

Der Bindemechanismus ist also derselbe. Intuitiv stelle ich mir einen Verschluss als Teil eines komplexeren Lambda-Ausdrucks vor. Wenn diese Repräsentation erstellt wird, wurden einige der Bindungen des Mutterausdrucks bereits festgelegt und der Abschluss verwendet sie später, wenn sie ausgewertet / aufgerufen wird.

"Lambda" in der Programmierung bedeutet üblicherweise "Lambda-Funktion" (oder auch "Lambda-Ausdruck", "Lambda-Term"). Wenn function ein benannter Codeblock ist, der vor seiner Verwendung definiert wurde, ist "lambda function" ein Codeblock (oder ein Ausdruck), der anstelle der Verwendung definiert wurde und als erstklassiger Bürger in einer Programmiersprache verwendet werden kann.

In JavaScript ES6 (2015) gibt es eine kurze Syntax zum Definieren von Lambdas mit der Bezeichnung "Pfeilfunktionen" . In C # wurde eine solche Syntax in .NET 3.0 eingeführt (um 2006) .

In der Mathematik hat ein "Funktions" -Begriff mehrere Bedeutungen, wobei sich eine der Bedeutungen auf die Notation einer Funktion bezieht (dh wie man sie aufschreibt), dann ist "Lambda-Funktion" (im Kalkül) eine spezielle Art von Funktionsnotation. Weitere Informationen finden Sie unter Lambda-Funktionen in Programmiersprachen .