什么是 lambda（函数）？

对于没有计算机科学背景的人来说，计算机科学世界中的 lambda 是什么？

答案

Lambda 来自Lambda 微积分，是指编程中的匿名函数。

为什么这很酷？它允许您编写快速抛出的函数而无需命名它们。它还提供了编写闭包的好方法。有了这种能力，您就可以做这样的事情。

蟒蛇

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

从 Python 片段中可以看到，函数加法器接受一个参数 x，并返回一个带另一个参数 y 的匿名函数或 lambda。该匿名函数允许您从函数创建函数。这是一个简单的示例，但它应该传达出 lambda 和闭包所具有的功能。

其他语言的例子

Perl 5

sub adder {
    my ($x) = @_;
    return sub {
        my ($y) = @_;
        $x + $y
    }
}

my $add5 = adder(5);
print &$add5(1) == 6 ? "ok\n" : "not ok\n";

的 JavaScript

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

JavaScript（ES6）

const adder = x => y => x + y;
add5 = adder(5);
add5(1) == 6

方案

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

C＃3.5 或更高

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

迅速

func adder(x: Int) -> (Int) -> Int{
   return { y in x + y }
}
let add5 = adder(5)
add5(1)
6

的 PHP

$a = 1;
$b = 2;

$lambda = function () use (&$a, &$b) {
    echo $a + $b;
};

echo $lambda();

哈斯克尔

(\x y -> x + y)

Java看到这篇文章

// The following is an example of Predicate : 
// a functional interface that takes an argument 
// and returns a boolean primitive type.

Predicate<Integer> pred = x -> x % 2 == 0; // Tests if the parameter is even.
boolean result = pred.test(4); // true

adder = function(x)
    return function(y)
        return x + y
    end
end
add5 = adder(5)
add5(1) == 6        -- true

科特林

val pred = { x: Int -> x % 2 == 0 }
val result = pred(4) // true

红宝石

Ruby 稍有不同，因为您不能使用与调用函数完全相同的语法来调用 lambda，但是它仍然具有 lambda。

def adder(x)
  lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6

Ruby 是 Ruby，它是 lambda 的简写形式，因此您可以通过以下方式定义adder ：

def adder(x)
  -> y { x + y }
end

adder <- function(x) {
  function(y) x + y
}
add5 <- adder(5)
add5(1)
#> [1] 6

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

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

确切的符号因语言而异；并非总是需要希腊语！ ;-)