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


当前回答

例如,在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来自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

你可以把它看作一个匿名函数-这里有更多信息:Wikipedia-匿名函数

因为我在这里看不到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”这个名字只是一个历史产物。我们所谈论的只是一个表达式,其值是一个函数。

一个简单的例子(下一行使用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)

确切的符号因语言而异;希腊语并不总是必需的!;-)

在CS的上下文中,lambda函数是一个抽象的数学概念,它解决了数学表达式的符号求值问题。在这种情况下,lambda函数与lambda项相同。

但在编程语言中,这是不同的。这是一段被宣布为“到位”的代码,可以作为“一流公民”传递。这个概念似乎很有用,因此它几乎进入了所有流行的现代编程语言(参见lambda函数everwhere post)。