Qu'est ce qu'un lambda (fonction)?

Question

Pour une personne sans comp-sci fond, qu'est ce qu'un lambda dans le monde de l'Informatique?

Answer 1

Lambda vient de le Lambda Calcul et renvoie à des fonctions anonymes dans la programmation.

Pourquoi est-ce cool? Il vous permet d'écrire rapidement jeter les fonctions sans les nommer. Il fournit également une belle façon d'écrire des fermetures. Avec ce pouvoir, vous pouvez faire des choses comme ça.

Python

def adder(x):
    return lambda y: x + y
add5 = adder(5)
add5(1)
6

JavaScript

var adder = function (x) {
    return function (y) {
        return x + y;
    };
};
add5 = adder(5);
add5(1) == 6

Régime

(define adder
    (lambda (x)
        (lambda (y)
           (+ x y))))
(define add5
    (adder 5))
(add5 1)
6

C# 3.5 ou supérieur

Func<int, Func<int, int>> adder = 
    (int x) => (int y) => x + y; // `int` declarations optional
Func<int, int> add5 = adder(5);
var add6 = adder(6); // Using implicit typing
Debug.Assert(add5(1) == 6);
Debug.Assert(add6(-1) == 5);

// Closure example
int yEnclosed = 1;
Func<int, int> addWithClosure = 
    (x) => x + yEnclosed;
Debug.Assert(addWithClosure(2) == 3);

Comme vous pouvez le voir dans l'extrait de Python et JavaScript, la fonction additionneur prend un argument x, et retourne une fonction anonyme, ou lambda, qui prend un argument de y. Cette fonction anonyme qui vous permet de créer des fonctions de fonctions. C'est un simple exemple, mais il doit transmettre la puissance des lambdas et des bouchons.

Answer 2

Un lambda est un type de fonction, définie sur la ligne. Avec un lambda-vous aussi souvent une sorte de type de variable qui peut contenir une référence à une fonction, lambda ou autrement.

Par exemple, voici un C# morceau de code qui n'utilise pas un 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);
}

Cela demande de la Calculatrice, en passant le long de ce ne sont pas deux numéros, mais la méthode à appeler à l'intérieur de la Calculatrice pour obtenir les résultats du calcul.

En C# 2.0 nous avons obtenu des méthodes anonymes, ce qui raccourcit le code ci-dessus:

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;
    });
}

Et puis C# 3.0 nous avons obtenu des lambdas qui rend le code encore plus courte:

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);
}

Answer 3

Le nom de "lambda" n'est qu'un artefact historique. Nous parlons est une expression dont la valeur est une fonction.

Un exemple simple (à l'aide de la Scala pour la ligne suivante) est:

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

d'où l'argument de l' foreach méthode est une expression pour une fonction anonyme. La ligne ci-dessus est plus ou moins la même chose que d'écrire quelque chose comme ceci (pas tout à fait vrai code, mais vous obtenez l'idée):

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

sauf que vous n'avez pas besoin de s'embêter avec:

1. Déclarer la fonction de quelque part d'autre (et d'avoir à les chercher quand vous revenez sur le code plus tard).
2. Nommage quelque chose que vous êtes seulement en utilisant une seule fois.

Une fois que vous êtes utilisé pour les valeurs de la fonction, le fait de devoir faire sans eux semble aussi ridicule que d'être nécessaire pour nom de chaque expression, telles que:

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

au lieu de simplement l'écriture de l'expression où vous en avez besoin:

println(2 * a + b)

La notation exacte varie d'une langue à l'autre; le grec n'est pas toujours nécessaire! ;-)

Answer 4

Il se réfère à la lambda calcul , qui est un système formel qui a juste les expressions lambda, qui représente une fonction qui prend une fonction pour son seul argument et retourne une fonction. Toutes les fonctions dans le lambda calcul sont de ce type, c'est à dire, λ : λ → λ.

Lisp utilisé le lambda concept au nom de sa fonction anonyme littéraux. Cette lambda représente une fonction qui prend deux arguments x et y, et retourne leur produit:

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

Il peut être appliqué en-ligne comme ceci (évalue à 50):

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

Answer 5

Le lambda calcul est une constante mathématique de la théorie de la substitution. En mathématiques à l'école on voit par exemple x+y=5 jumelé avec x−y=1. Avec les moyens de manipuler des équations individuelles, il est aussi possible de mettre l'information à partir de ces deux ensemble, à condition de la croix-équation de substitutions sont fait logiquement. Lambda calcul codifie la façon correcte de faire de ces substitutions.

Étant donné qu' y = x−1 est valable un réarrangement de la deuxième équation, c': λ y = x−1 moyen d'une fonction de substitution de symboles x−1 pour le symbole y. Maintenant, imaginez appliquant λ y de chaque terme dans la première équation. Si un terme est - y puis effectuer la substitution; sinon ne rien faire. Si vous faites cela sur le papier, vous verrez comment appliquer qu' λ y fera la première équation résoluble.

C'est une réponse sans n'importe quel ordinateur de la science ou de la programmation.

Le plus simple exemple de programmation je pense, vient de http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works:

voici comment le carré de la fonction peut être définie dans un impératif langage de programmation (C):

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

La variable x est un paramètre formel qui est remplacé par le valeur au carré lorsque la fonction est appelée. Dans une fonctionnelle langue (Schéma) de la même fonction est définie:

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

C'est différent à bien des égards, mais il utilise toujours le paramètre formel x de la même manière.