Quelle est la différence entre une fonction et un lambda?

Je suis un peu confus à propos de 'fonction' et de 'lambda'. J'ai vu des exemples montrant que le mot-clé scheme lambdafonctionne de manière très similaire au mot function- clé JavaScript , mais je ne sais vraiment pas comment ils sont associés.

On me dit que «fonction» et «méthode» peuvent être utilisés de manière interchangeable lorsque l'on parle d'objets dans .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 un sens ésotérique, vu que la lettre grecque lambda (λ) apparaît dans de nombreux avatars sur ce site. Pour rendre les choses encore plus confuses, dans .net, les parties fonctionnelles de C # font référence à des expressions de fonction transmises à une autre fonction sous le nom d '"expressions lambda", de sorte que 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" désigne le plus souvent des fonctions anonymes. Donc, dans ce sens, un lambda est une sorte de fonction, mais chaque fonction n’est pas nécessairement un lambda (c’est-à-dire que les fonctions nommées ne sont généralement pas appelées lambdas). En fonction du langage, les fonctions anonymes sont souvent implémentées différemment des fonctions nommées (en particulier dans les langages 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 de scheme et le mot-clé function Javascript est que ce dernier peut être utilisé pour créer des fonctions anonymes et des fonctions nommées alors que le premier ne crée que des fonctions anonymes (et que vous utiliseriez definepour créer des fonctions nommées).

Le lambda calcul est un langage de programmation / modèle mathématique minimal, qui utilise les fonctions comme seule "structure de données". Dans le calcul de lamdba, le symbole lambda est utilisé pour créer des fonctions (anonymes). C’est d’où vient l’emploi 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

En gros, 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 de délégué sans déclaration de méthode).

Les expressions lambda peuvent être décomposées en expression lambda et statement lambda

Expression lambda:

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

L'instruction lambda est similaire à l'expression lambda, à l'exception des expressions qui sont 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 en tant qu'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 est simplement un moyen de définir des fonctions sans être obligé de leur donner un nom.

Version longue

Je voudrais élaborer un peu sur ce sujet parce que je le trouve très intéressant. Disclaimer: J'ai suivi mon cours de lambda calcul il y a longtemps. Si une personne mieux informée trouve des inexactitudes dans ma réponse, n'hésitez pas à m'aider à l'améliorer.

Commençons par les expressions, par exemple 1 + 2et x + 2. Les littéraux tels que 1et 2sont appelés des constantes car ils sont liés à des valeurs fixes spécifiques.

Un identifiant tel que celui xappelé variable et afin de l’évaluer, vous devez d’abord le lier à une valeur. Donc, fondamentalement, vous ne pouvez pas évaluer x + 1tant que vous ne savez pas ce que xc'est.

La notation lambda fournit un schéma permettant de lier des valeurs d’entrée spécifiques à des variables. Une expression lambda peut être formée en ajoutant λx .devant une expression existante, par exemple λx . x + 1. Variable xest dit être libre dans x + 1et lié àλ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 (reliant) toutes les occurrences de la variable xpar la valeur 2:

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

Ainsi, la notation lambda fournit un mécanisme général pour lier des éléments à des variables qui apparaissent dans un bloc d'expression / programme. Selon le contexte, cela crée des concepts très différents dans les langages de programmation:

• Dans un langage purement fonctionnel comme Haskell, les expressions lambda représentent des 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 nombreuses langues (JavaScript, Python, Scheme, par exemple), 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.

La prochaine étape consiste à donner un nom à une fonction / procédure. Dans plusieurs langues, les fonctions sont des valeurs comme toutes les autres, vous pouvez donc nommer 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 Eli Barzilay l'a souligné, ces définitions ne font que lier le nom fà une valeur, qui se trouve être une fonction. Ainsi, à cet égard, les fonctions, les nombres, les chaînes, les caractères sont des valeurs pouvant être liées à des 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 langues, vous pouvez également associer une fonction à un nom en utilisant la notation plus connue (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 supportent cette dernière notation que pour définir des fonctions (nommées).

Fermetures

Quelques observations finales concernant les fermetures . Considérez l'expression x + y. Ceci contient deux variables libres. Si vous vous liez en xutilisant 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 identique à la +fonction.

Mais vous pouvez lier, par exemple, yd’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.

Il en incrementBy 5va de même pour 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 une partie 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 ultérieurement lors de son évaluation / invocation.

"Programmation" signifie généralement "fonction lambda" (ou "expression lambda", "terme lambda"). Lorsque fonction est un bloc de code nommé défini avant son utilisation, "fonction lambda" est un bloc de code (ou une expression) défini à la place de l'utilisation pouvant ê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 "Fonctions de flèche" . En C #, cette syntaxe a été introduite dans .NET 3.0 (vers 2006) .

En mathématiques, une notion de "fonction" a plusieurs significations, l'une des significations étant la notation d'une fonction (c'est-à-dire comment l'écrire), puis "fonction lambda" (en calcul) est un type spécial de notation de fonction. Pour plus de discussion, vérifiez les fonctions lambda dans les langages de programmation .