Quelle est la différence entre une fonction et un lambda?
Je suis un peu confus au sujet de "fonction" et "lambda". J'ai vu quelques exemples montrant que le mot clé de schéma lambda fonctionne de manière très similaire au mot clé JavaScript function, mais je ne sais vraiment pas comment ils sont liés.
On me dit que "fonction" et "méthode" peuvent être utilisées de manière interchangeable lorsque l'on parle d'objets en .net. Je me demande si "lambda" et "fonction" signifient de la même façon la même chose. Je me demande si 'lambda' a une signification ésotérique, vu que la lettre grecque lambda (λ) apparaît dans tant d'avatars sur ce site. Pour rendre les choses encore plus confuses, dans .net, les parties fonctionnelles de C # se réfèrent aux expressions de fonction passées à une autre fonction en tant qu '"expressions lambda", donc le mot semble vraiment être partout.
Je connais aussi vaguement le terme "calcul lambda".
Quelle est la différence entre une fonction et un lambda?
Le mot "lambda" ou "expressions lambda" se réfère le plus souvent à des fonctions anonymes. Donc, dans ce sens, un lambda est une sorte de fonction, mais toutes les fonctions ne sont pas un lambda (c'est-à-dire que les fonctions nommées ne sont généralement pas appelées lambdas). En fonction de la langue, les fonctions anonymes sont souvent implémentées différemment des fonctions nommées (en particulier dans les langues où les fonctions anonymes sont des fermetures et les fonctions nommées ne le sont pas), il est donc logique de s'y référer avec des termes différents.
La différence entre le mot-clé lambda du schéma et le mot-clé de fonction Javascript est que ce dernier peut être utilisé pour créer à la fois des fonctions anonymes et des fonctions nommées tandis que le premier crée uniquement des fonctions anonymes (et vous utiliseriez define pour créer des fonctions nommées).
Le calcul lambda est un langage de programmation minimal/modèle mathématique de calcul, qui utilise les fonctions comme sa seule "structure de données". Dans le calcul lamdba, le symbole lambda est utilisé pour créer des fonctions (anonymes). C'est de là que vient l'utilisation du terme "lambda" dans d'autres langues.
Un lambda est simplement une fonction anonyme - une fonction sans nom.
Répondu ici: https://stackoverflow.com/questions/16501/what-is-a-lambda-function
Fondamentalement, Lambda est une fonction anonyme.
En C # fonction anonyme est un terme général qui inclut à la fois les expressions lambda et les méthodes anonymes (les méthodes anonymes sont des instances déléguées sans déclaration de méthode réelle).
expressions lambda peut être décomposé en expression lambda et instruction lambda
Expression lambda:
(int x, string y) => x == y.Length
L'instruction lambda est similaire à l'expression lambda, sauf que les instructions sont placées entre accolades:
(int x, string y) => {
if (x == y.Length) {
Console.WriteLine(y);
}
}
Lorsque nous parlons d'expressions lambda en JavaScript, cela signifie simplement utiliser une fonction comme argument dans un appel à une autre fonction.
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 Comme d'autres l'ont souligné: la notation lambda n'est qu'un moyen de définir des fonctions sans être obligé de leur donner un nom.
version longue
Je voudrais développer un peu ce sujet car je le trouve très intéressant. Avertissement: J'ai suivi mon cours sur le calcul lambda il y a longtemps. Si quelqu'un avec une meilleure connaissance trouve des inexactitudes dans ma réponse, n'hésitez pas à m'aider à l'améliorer.
Commençons par les expressions, par exemple 1 + 2 et x + 2. Littéraux tels que 1 et 2 sont appelés constantes car ils sont liés à des valeurs fixes spécifiques.
Un identifiant tel que x est appelé variable et pour l'évaluer, vous devez d'abord le lier à une valeur. Donc, fondamentalement, vous ne pouvez pas évaluer x + 1 tant que vous ne savez pas ce qu'est x.
La notation lambda fournit un schéma pour lier des valeurs d'entrée spécifiques à des variables. Un expression lambda peut être formé en ajoutant λx . devant une expression existante, par ex. λx . x + 1. La variable x serait free in x + 1 et lié dans λx . x + 1
Comment cela aide-t-il à évaluer les expressions? Si vous introduisez une valeur dans l'expression lambda, comme ceci
(λx . x + 1) 2
alors vous pouvez évaluer l'expression entière en remplaçant (liant) toutes les occurrences de la variable x par la valeur 2:
(λx . x + 1) 2
2 + 1
3
Ainsi, la notation lambda fournit un mécanisme général pour lier des choses à des variables qui apparaissent dans un bloc d'expression/programme. Selon le contexte, cela crée des concepts visiblement différents dans les langages de programmation:
- Dans un langage purement fonctionnel comme Haskell, les expressions lambda représentent fonctions au sens mathématique: une valeur d'entrée est injectée dans le corps du lambda et une valeur de sortie est produite.
- Dans de nombreux langages (par exemple JavaScript, Python, Scheme), l'évaluation du corps d'une expression lambda peut avoir des effets secondaires. Dans ce cas, on peut utiliser le terme procédure pour marquer la différence par rapport aux fonctions pures.
Outre les différences, la notation lambda consiste à définir des paramètres formels et à les lier à des paramètres réels.
L'étape suivante consiste à donner un nom à une fonction/procédure. Dans plusieurs langues, les fonctions sont des valeurs comme les autres, vous pouvez donc donner un nom à une fonction comme suit:
(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
Comme l'a souligné Eli Barzilay, ces définitions lient simplement le nom f à une valeur, qui se trouve être une fonction. Donc, à cet égard, les fonctions, les nombres, les chaînes, les caractères sont toutes des valeurs qui peuvent être liées aux noms de la même manière:
(define n 42) ;; Scheme
n = 42 -- Haskell
val n: Int = 42 // Scala
var n = 42 // JavaScript
n = 42 # Python
Dans ces langages, vous pouvez également lier une fonction à un nom en utilisant la notation plus familière (mais équivalente):
(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
Certaines langues, par exemple C, ne prend en charge que la dernière notation pour définir les fonctions (nommées).
Fermetures
Quelques observations finales concernant fermetures. Considérez l'expression x + y. Celui-ci contient deux variables libres. Si vous liez x en utilisant la notation lambda, vous obtenez:
\x -> x + y
Ce n'est pas (encore) une fonction car elle contient toujours une variable libre y. Vous pouvez en faire une fonction en liant y également:
\x -> \y -> x + y
ou
\x y -> x + y
ce qui est le même que le + une fonction.
Mais vous pouvez lier, disons, y d'une autre manière (*):
incrementBy y = \x -> x + y
Le résultat de l'application de la fonction incrementBy à un nombre est une fermeture, c'est-à-dire une fonction/procédure dont le corps contient une variable libre (par exemple y) qui a été liée à une valeur de l'environnement dans lequel la fermeture a été définie.
Donc incrementBy 5 est la fonction (fermeture) qui incrémente les nombres de 5.
REMARQUE (*)
Je triche un peu ici:
incrementBy y = \x -> x + y
est équivalent à
incrementBy = \y -> \x -> x + y
donc le mécanisme de liaison est le même. Intuitivement, je pense qu'une fermeture représente un morceau d'une expression lambda plus complexe. Lorsque cette représentation est créée, certaines des liaisons de l'expression mère ont déjà été définies et la fermeture les utilise plus tard lorsqu'elle est évaluée/invoquée.
"Lambda" dans la programmation signifie généralement "fonction lambda" (ou aussi "expression lambda", "terme lambda"). Lorsque la fonction est un bloc de code nommé défini avant son utilisation, la "fonction lambda" est un bloc de code (ou une expression) défini à la place de l'utilisation qui peut être utilisé en tant que citoyen de première classe dans un langage de programmation.
Dans JavaScript ES6 (2015), il existe une courte syntaxe pour définir les lambdas appelée "Arrow Functions" . En C # une telle syntaxe a été introduite dans .NET 3.0 (vers 2006) .
En mathématiques, une notion de "fonction" a plusieurs significations où l'une des significations concerne la notation d'une fonction (c'est-à-dire comment l'écrire), alors "fonction lambda" (en calcul) est un type spécial de notation de fonction. Pour plus de discussion, vérifiez fonctions lambda dans les langages de programmation .