它指的是lambda演算，这是一个只有lambda表达式的形式系统，lambda表达式表示一个函数，该函数将一个函数作为其唯一参数并返回一个函数。lambda演算中的所有函数都是这种类型的，即λ：λ→ λ.

Lisp使用lambda概念来命名其匿名函数文字。此lambda表示一个函数，它接受两个参数x和y，并返回它们的乘积：

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

它可以这样在线应用（计算为50）：

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

它指的是lambda演算，这是一个只有lambda表达式的形式系统，lambda表达式表示一个函数，该函数将一个函数作为其唯一参数并返回一个函数。lambda演算中的所有函数都是这种类型的，即λ：λ→ λ.

Lisp使用lambda概念来命名其匿名函数文字。此lambda表示一个函数，它接受两个参数x和y，并返回它们的乘积：

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

它可以这样在线应用（计算为50）：

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

lambda是一种内联定义的函数类型。除了lambda之外，通常还有某种类型的变量类型，可以保存对函数lambda或其他函数的引用。

例如，这里有一段不使用lambda的C#代码：

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

这调用Calculator，不仅传递两个数字，还传递要在Calculator中调用的方法以获得计算结果。

在C#2.0中，我们得到了匿名方法，这将上述代码缩短为：

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

然后在C#3.0中，我们得到了lambdas，这使得代码更短：

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

例如，在Javascript中，函数被视为与其他所有类型（int、string、float、bool）相同的混合类型。因此，您可以动态创建函数，将它们分配给对象，然后稍后再调用它们。它是有用的，但不是你想过度使用的东西，否则你会让所有在你之后必须维护代码的人感到困惑。。。

这是我玩的一些代码，看看这个兔子洞有多深：

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]()()();

“lambda”这个名字只是一个历史产物。我们所谈论的只是一个表达式，其值是一个函数。

一个简单的例子（下一行使用Scala）是：

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

其中foreach方法的参数是匿名函数的表达式。上面的一行与编写类似的代码大致相同（不是真正的代码，但你会明白的）：

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

除了你不需要麻烦：

在其他地方声明函数（稍后重新访问代码时必须查找它）。命名你只使用一次的东西。

一旦你习惯了函数值，就不得不不使用它们，就像需要命名每个表达式一样愚蠢，比如：

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

而不是只在需要的地方编写表达式：

println(2 * a + b)

确切的符号因语言而异；希腊语并不总是必需的！；-）

lambda函数可以接受任意数量的参数，但它们只包含一个表达式。。。Lambda函数可用于返回函数对象。语法上，lambda函数仅限于一个表达式。