lambda演算是一种一致的替代数学理论。例如，在学校数学中，人们可以看到x+y=5与x−y=1配对。除了处理单个方程的方法外，还可以将这两个方程的信息放在一起，前提是交叉方程的替换是合乎逻辑的。Lambda演算编纂了进行这些替换的正确方法。

假设y=x−1是第二个方程的有效重排，这：λy=x–1表示用符号x−1代替符号y的函数。现在想象将λy应用于第一个方程中的每个项。如果项是y，则执行替换；否则什么都不做。如果你在纸上这样做，你会看到应用λy将如何使第一个方程可解。

这是一个没有任何计算机科学或编程的答案。

我能想到的最简单的编程示例来自http://en.wikipedia.org/wiki/Joy_（编程语言）#如何工作：

下面是如何在命令中定义平方函数编程语言（C）：int平方（int x）{返回x*x；}变量x是一个形式参数，由实际调用函数时要平方的值。在函数中语言（方案）将定义相同的功能：（定义正方形（λ（x）（*x x）））这在很多方面都不同，但它仍然使用形式参数x以相同的方式。

补充：http://imgur.com/a/XBHub

在计算机编程中，lambda是一段代码（语句、表达式或一组代码），它从外部源获取一些参数。它不能总是一个匿名函数——我们有很多方法来实现它们。

我们在表达式、语句和函数之间有明确的区分，而数学家没有这种区分。

编程中的“函数”一词也有所不同——我们有“函数是一系列要做的步骤”（来自拉丁语“perform”）。在数学中，它是关于变量之间的相关性。

函数语言正试图尽可能地与数学公式相似，它们的单词意思几乎相同。但在其他编程语言中，我们有不同之处。

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

因为我在这里看不到C++11示例，所以我将继续在这里发布这个很好的示例。经过搜索，这是我能找到的最清晰的语言特定示例。

你好，Lambdas，版本1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

你好，Lambdas，版本2：

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}

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

“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)

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