[lambda] 람다는 무엇입니까?

Lambda는 Lambda Calculus 에서 제공 되며 프로그래밍에서 익명 함수를 나타냅니다.

이것이 왜 시원합니까? 이름을 지정하지 않고 빠른 처리 기능을 작성할 수 있습니다. 또한 클로저를 작성하는 좋은 방법을 제공합니다. 그 힘으로 이런 일을 할 수 있습니다.

파이썬

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

파이썬 스 니펫에서 알 수 있듯이 함수 adder는 인수 x를 취하고 다른 인수 y를 취하는 익명 함수 또는 람다를 반환합니다. 이 익명 함수를 사용하면 함수에서 함수를 만들 수 있습니다. 이것은 간단한 예이지만 람다와 클로저의 힘을 전달해야합니다.

다른 언어의 예

펄 5

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

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

자바 스크립트

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

자바 스크립트 (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)

자바이 게시물을 참조하십시오

// 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

루비

루비는 함수를 호출하는 것과 동일한 구문을 사용하여 람다를 호출 할 수는 없지만 람다가 있다는 점에서 약간 다릅니다.

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

루비는 루비이기 때문에 람다의 축약 형 adder이 있으므로 다음과 같이 정의 할 수 있습니다 .

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

아르 자형

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

답변

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

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

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

args.foreach(arg => println(arg))

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

int tempVar = 2 * a + b
...
println(tempVar)

println(2 * a + b)

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

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

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

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

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

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