Ruby中lambda的示例如下：

hello = lambda do
    puts('Hello')
    puts('I am inside a proc')
end

hello.call

将生成以下输出：

Hello
I am inside a proc

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

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

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

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

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

Lambda函数或小型匿名函数是一个自包含的功能块，可以在代码中传递和使用。Lambda在不同的编程语言中有不同的名称——Python和Kotlin中的Lambda，Swift中的闭包，或者C和Objective-C中的Block。虽然lambda在这些语言中的含义非常相似，但有时会有细微差别。

让我们看看Closure（Lambda）在Swift中的工作原理：

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1.正则函数

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

2.闭包表达式

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in   
    return n1 > n2
})

3.内联闭包表达式

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in 
    return n1 > n2 
})

4.根据上下文推断类型

reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )

5.单表达式闭包的隐式返回

reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )

6.速记参数名称

reverseOrder = coffee.sorted(by: { $0 > $1 } )

// $0 and $1 are closure’s first and second String arguments.

7.操作员方法

reverseOrder = coffee.sorted(by: >)

// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

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

想象一下，你有一家餐厅提供送货服务，你的订单需要在30分钟内完成。关键是客户通常不在乎你是骑自行车送食物还是赤脚送食物，只要你保持食物的温度并系好。因此，让我们将这个习惯用法转换为带有匿名和定义的传输函数的Javascript。

下面我们定义了交付的方式，也就是我们定义了函数的名称：

// ES5 
var food = function withBike(kebap, coke) {
return (kebap + coke); 
};

如果我们使用箭头/lambda函数来完成此传输会怎么样：

// ES6    
const food = (kebap, coke) => { return kebap + coke };

你看，对客户来说并没有什么区别，也并没有浪费时间去思考如何发送食物。只要发送它。

顺便说一句，我不推荐用可乐烤串，这就是为什么上面的代码会给你错误。玩得高兴

我喜欢这篇文章中对Lambdas的解释：LINQ的演变及其对C#设计的影响。这对我来说很有意义，因为它为Lambdas展示了一个真实的世界，并将其作为一个实际的例子。

他们的快速解释：Lambdas是将代码（函数）视为数据的一种方式。