对于一个没有计算机科学背景的人来说,计算机科学界的lambda是什么?


当前回答

它是一个没有名称的函数。例如,在c#中,您可以使用

numberCollection.GetMatchingItems<int>(number => number > 5);

返回大于5的数字。

number => number > 5

这里是lambda部分。它表示一个接受参数(数字)并返回布尔值(数字>5)的函数。GetMatchingItems方法对集合中的所有项使用此lambda并返回匹配项。

其他回答

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

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

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

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

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

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

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

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

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

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

它可以这样在线应用(计算为50):

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

Lambda来自Lambda演算,指编程中的匿名函数。

为什么这么酷?它允许您在不命名的情况下编写快速丢弃函数。它还提供了一种编写闭包的好方法。有了这种力量,你可以做这样的事情。

蟒蛇

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

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

其他语言示例

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 = fn () => $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

Lua

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

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

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

Ruby是Ruby,有一个lambdas的简写,所以您可以这样定义加法器:

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

R

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

有点过于简单:lambda函数是一个可以传递给其他函数的函数,它的逻辑被访问。

在C#中,lambda语法通常以与匿名委托相同的方式编译为简单方法,但它也可以分解并读取其逻辑。

例如(在C#3中):

LinqToSqlContext.Where( 
    row => row.FieldName > 15 );

LinqToSql可以读取该函数(x>15)并将其转换为实际的SQL以使用表达式树执行。

上述声明变为:

select ... from [tablename] 
where [FieldName] > 15      --this line was 'read' from the lambda function

这与普通方法或匿名委托不同(它们实际上只是编译器的魔法),因为它们无法读取。

并非C#中所有使用lambda语法的方法都可以编译为表达式树(即实际的lambda函数)。例如:

LinqToSqlContext.Where( 
    row => SomeComplexCheck( row.FieldName ) );

现在无法读取表达式树-无法分解SomeComplexCheck。SQL语句将在没有where的情况下执行,数据中的每一行都将通过SomeComplexCheck进行处理。

Lambda函数不应与匿名方法混淆。例如:

LinqToSqlContext.Where( 
    delegate ( DataRow row ) { 
        return row.FieldName > 15; 
    } );

这也有一个“内联”函数,但这一次它只是编译器的魔法——C#编译器会将其拆分为一个具有自动生成名称的新实例方法。

匿名方法不能被读取,因此逻辑不能像lambda函数那样被翻译出来。

我很难理解lambda表达式,因为我在Visual FoxPro中工作,它具有宏替换以及ExecScript{}和Evaluate()函数,这两个函数似乎起着相同的作用。

? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");

FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)

使用正式lambda的一个明确好处是(我假设)编译时检查:Fox在尝试运行之前不会知道您是否键入了上面的文本字符串。

这对于数据驱动的代码也很有用:您可以将整个例程存储在数据库中的备注字段中,然后在运行时对其求值。这允许您调整应用程序的一部分,而无需实际访问源代码。(但这完全是另一个话题。)