ํฌ์ŠคํŠธ

C# Lambda-Expression | ๋žŒ๋‹ค์‹

C# Lambda-Expression | ๋žŒ๋‹ค์‹

๐Ÿ’ซ Q


  • ๋žŒ๋‹ค์‹ ?
  • ๋žŒ๋‹ค์‹์„ ์„ ์–ธํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•
  • ๋ฌธ ํ˜•์‹์˜ ๋žŒ๋‹ค์‹์„ ์ž‘์„ฑํ•˜๊ณ  ์‚ฌ์šฉํ•˜๋Š” ๋ฐฉ๋ฒ•
  • ์‹ ํŠธ๋ฆฌ

๐Ÿ’ซ Lambda-Expression | ๋žŒ๋‹ค์‹


์ต๋ช…-๋ฉ”์†Œ๋“œ๋ฅผ ๋งŒ๋“œ๋Š” ๋˜ ํ•˜๋‚˜์˜ ๋ฐฉ๋ฒ•.
๋žŒ๋‹ค์‹์œผ๋กœ ๋งŒ๋“œ๋Š” ์ต๋ช… ๋ฉ”์†Œ๋“œ๋Š” ๋ฌด๋ช…-ํ•จ์ˆ˜(Anonymous Function)๋ผ๋Š” ์ด๋ฆ„์œผ๋กœ ๋ถ€๋ฅธ๋‹ค.

๐Ÿซง Lambda-Expression ๊ตฌํ˜„

(๋งค๊ฐœ๋ณ€์ˆ˜) => ์‹ ๊ฐ™์€ ๋ชจ์–‘์œผ๋กœ ๋งŒ๋“ ๋‹ค.

=> ๋Š” ์ž…๋ ฅ ์—ฐ์‚ฐ์ž (ํ˜น์€ ๋žŒ๋‹ค ์—ฐ์‚ฐ์ž(Lambda Operator)).
=>๋ฅผ ์ค‘์‹ฌ์œผ๋กœ ์™ผ์ชฝ์—๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜, ์˜ค๋ฅธ์ชฝ์—๋Š” ์‹์ด ์œ„์น˜.
๊ทธ์ € ์™ผ์ชฝ ๋งค๊ฐœ ๋ณ€์ˆ˜๋ฅผ ์˜ค๋ฅธ์ชฝ ์‹์— ์ „๋‹ฌํ•˜๋Š” ์—ญํ• .

1
(int x, int y) => x + y

๐Ÿซง Type-Inference | ํƒ€์ž… ์ถ”๋ก (ํ˜•์‹ ์œ ์ถ”)

C# ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์ฝ”๋“œ๋ฅผ ํ•œ์ธต ๋” ๊ฐ„๊ฒฐํ•˜๊ฒŒ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋„๋ก ํƒ€์ž… ์ถ”๋ก (ํ˜•์‹ ์œ ์ถ”) (Type-Inference)๋ฅผ ์ง€์›ํ•œ๋‹ค.
ํƒ€์ž… ์ถ”๋ก ์„ ์ด์šฉํ•˜๋ฉด ๋žŒ๋‹ค์‹์—์„œ ๋งค๊ฐœ ๋ณ€์ˆ˜์˜ ํƒ€์ž…์„ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ๋‹ค.

1
2
3
4
delegate int MyDelegate(int x, int y);

// C# ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ `delegate`์˜ ์„ ์–ธ ์ฝ”๋“œ๋กœ๋ถ€ํ„ฐ ๋ฌด๋ช… ํ•จ์ˆ˜์˜ ๋งค๊ฐœ ๋ณ€์ˆ˜ ํƒ€์ž…์„ ์ถ”๋ก ํ•ด๋‚ธ๋‹ค.
MyDelegate myDelegate = (x, y) => x + y;

๐Ÿซง Lambda-Expression Why?

๋žŒ๋‹ค์‹์œผ๋กœ ๋งŒ๋“œ๋Š” ๋ฌด๋ช…ํ•จ์ˆ˜๋Š”, ๋Œ€๋ฆฌ์ž๋ฅผ ์ด์šฉํ•œ ์ต๋ช… ๋ฉ”์†Œ๋“œ๋ณด๋‹ค ๊ฐ„๊ฒฐํ•˜๋‹ค.

๋” ๋ฒˆ๊ฑฐ๋กœ์šด ๋ฐฉ๋ฒ•๊ณผ ๋” ๊ฐ„๊ฒฐํ•œ ๋ฐฉ๋ฒ•์ด ๋™์‹œ์— ์กด์žฌํ•˜๋Š” ์ด์œ  ?
๋Œ€๋ฆฌ์ž๋ฅผ ์ด์šฉํ•œ ์ต๋ช… ๋ฉ”์†Œ๋“œ๋Š” C# 2.0์—์„œ ๋„์ž…, ๋žŒ๋‹ค์‹์€ C# 3.0์—์„œ ๋„์ž….
ํ•˜์œ„ ํ˜ธํ™˜์„ฑ์„ ์œ ์ง€ํ•˜๊ธฐ ์œ„ํ•ด ๋‘ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์„ ๋ชจ๋‘ ์ง€์›.

1
2
3
4
5
6
7
delegate int MyDelegate(int x, int y);

// ์ต๋ช…-๋ฉ”์†Œ๋“œ
MyDelegate myDelegate = delegate (int x, int y) { return x + y; };

// ๋žŒ๋‹ค์‹
MyDelegate myDelegate = (x, y) => x + y;

๐Ÿซง Statement Lambda | ๋ฌธ ํ˜•์‹์˜ ๋žŒ๋‹ค์‹

์‹ ํ˜•์‹์˜ ๋žŒ๋‹ค์‹๋Š” => ์—ฐ์‚ฐ์ž์˜ ์˜ค๋ฅธํŽธ์— ์‹์„ ์‚ฌ์šฉ.
๋ฌธ ํ˜•์‹์˜ ๋žŒ๋‹ค์‹์€ => ์—ฐ์‚ฐ์ž์˜ ์˜ค๋ฅธํŽธ์— ์ค‘๊ด„ํ˜ธ({})๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ฝ”๋“œ ๋ธ”๋ก์„ ์ž‘์„ฑ.

์—ฌ๋Ÿฌ ์ค„์˜ ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, return ํ‚ค์›Œ๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋ฐ˜ํ™˜๊ฐ’์„ ์ง€์ •ํ•  ์ˆ˜ ์žˆ๋‹ค.
๋ฐ˜ํ™˜ ํ˜•์‹์ด ์—†๋Š” ๋ฌด๋ช…-ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

1
2
3
4
5
6
7
8
9
10
11
12
13
(int x, int y) => { /* ... */ }
(int x, int y) =>
{
	// ...
	return x + y;
}

( ) => { /* ... */ }
( ) =>
{
	// ...
	return 0;
}

๐Ÿ’ซ Expression-Tree | ์‹-ํŠธ๋ฆฌ


์‹์„ ํŠธ๋ฆฌ๋กœ ํ‘œํ˜„ํ•œ ์ž๋ฃŒ ๊ตฌ์กฐ.

์˜ˆ๋ฅผ ๋“ค์–ด 1 * 2 + (7 - 8) ๊ฐ™์€ ์‹์„ ํŠธ๋ฆฌ๋กœ ํ‘œํ˜„ํ•˜๋ฉด ์•„๋ž˜๊ณผ ๊ฐ™๋‹ค.

1
2
3
4
5
   +
  / \
 *   -
/ \ / \
1 2 7 8

์‹ ํŠธ๋ฆฌ์—์„œ ์—ฐ์‚ฐ์ž๋Š” ๋ถ€๋ชจ ๋…ธ๋“œ๊ฐ€ ๋˜๋ฉฐ, ํ”ผ์—ฐ์‚ฐ์ž๋Š” ์ž์‹ ๋…ธ๋“œ๊ฐ€ ๋œ๋‹ค.
์ด๋ ‡๊ฒŒ ์‹ ํŠธ๋ฆฌ๋กœ ํ‘œํ˜„๋œ ์‹์€ ํŠธ๋ฆฌ์˜ ์žŽ ๋…ธ๋“œ๋ผ๋ฆฌ ๊ณ„์‚ฐํ•ด์„œ ์ฐจ๋ก€์ฐจ๋ก€ ๋ฃจํŠธ๊นŒ์ง€ ์˜ฌ๋ผ๊ฐ€๋ฉด ์ „์ฒด ์‹์˜ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๋‹ค.

๐Ÿซง Expression-Tree Why?

์™„์ „ํ•œ C# ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ์•„๋‹ˆ์ง€๋งŒ,
ํ”„๋กœ๊ทธ๋ž˜๋จธ๊ฐ€ ์ฝ”๋“œ ์•ˆ์—์„œ ์ง์ ‘ ์‹ ํŠธ๋ฆฌ๋ฅผ ์กฐ๋ฆฝํ•˜๊ณ  ์ปดํŒŒ์ผํ•ด์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ๊ธฐ๋Šฅ์„ ์ œ๊ณต.
๋‹ค์‹œ ๋งํ•ด, ํ”„๋กœ๊ทธ๋žจ ์‹คํ–‰ ์ค‘์— ๋™์ ์œผ๋กœ ๋ฌด๋ช… ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค์–ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ค€๋‹ค๋Š” ์ด์•ผ๊ธฐ.

์‹ ํŠธ๋ฆฌ ์ž๋ฃŒ ๊ตฌ์กฐ๋Š” ์ปดํŒŒ์ผ๋Ÿฌ๋‚˜ ์ธํ„ฐํ”„๋ฆฌํ„ฐ๋ฅผ ์ œ์ž‘ํ•˜๋Š” ๋ฐ๋„ ์‘์šฉ.
์ปดํŒŒ์ผ๋Ÿฌ๋Š” ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์˜ ๋ฌธ๋ฒ•์„ ๋”ฐ๋ผ ์ž‘์„ฑ๋œ ์†Œ์Šค ์ฝ”๋“œ๋ฅผ ๋ถ„์„ํ•ด์„œ ์‹ ํŠธ๋ฆฌ๋กœ ๋งŒ๋“  ํ›„, ์ด๋ฅผ ๋ฐ”ํƒ•์œผ๋กœ ์‹คํ–‰ ํŒŒ์ผ์„ ๋งŒ๋“ ๋‹ค.

๐Ÿ’ซ Expression


๐Ÿซง Expression Class

Expression ํด๋ž˜์Šค์™€ ์•„์ด๋“ค(ํŒŒ์ƒ ํด๋ž˜์Šค๋“ค).
์‹ ํŠธ๋ฆฌ๋ฅผ ๋‹ค๋ฃจ๋Š”๋ฐ ํ•„์š”ํ•œ ํด๋ž˜์Šค.

System.Linq.Expressions๋„ค์ž„์ŠคํŽ˜์ด์Šค์— ์ •์˜๋˜์–ด ์žˆ๋‹ค.

Expression ํด๋ž˜์Šค๋Š” ์‹ ํŠธ๋ฆฌ๋ฅผ ๊ตฌ์„ฑํ•˜๋Š” ๋…ธ๋“œ๋ฅผ ํ‘œํ˜„
๊ทธ๋ž˜์„œ Expression์„ ์ƒ์†๋ฐ›๋Š” ํŒŒ์ƒ ํด๋ž˜์Šค๋“ค ์—ญ์‹œ ์‹ ํŠธ๋ฆฌ์˜ ๊ฐ ๋…ธ๋“œ๋ฅผ ํ‘œํ˜„

Expression ํด๋ž˜์Šค๋Š” ํŒŒ์ƒ ํด๋ž˜์Šค๋“ค์˜ ๊ฐ์ฒด๋ฅผ ์ƒ์„ฑํ•˜๋Š” ์—ญํ• ๋„ ๋‹ด๋‹น
ํŒŒ์ƒ ํด๋ž˜์Šค์˜ ์ธ์Šคํ„ด์Šค๋ฅผ ์ƒ์„ฑํ•˜๋Š” ์ •์  ํŒฉํ† ๋ฆฌ ๋ฉ”์†Œ๋“œ๋ฅผ ์ œ๊ณต.

Expression ํด๋ž˜์Šค ์ž์ฒด๋Š” ์ถ”์ƒ ํด๋ž˜์Šค์ด๋ฏ€๋กœ ์ง์ ‘ ์ธ์Šคํ„ด์Šค๋ฅผ ์ƒ์„ฑํ•  ์ˆ˜๋Š” ์—†๋‹ค.

๐Ÿซง Expression ๊ตฌํ˜„

Expressin ํด๋ž˜์Šค์˜ ์ •์  ํŒฉํ† ๋ฆฌ ๋ฉ”์†Œ๋“œ๋ฅผ ํ†ตํ•œ ๊ฐ์ฒด ์ƒ์„ฑ.

ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๊ฐ ๋…ธ๋“œ๊ฐ€ ์–ด๋–ค ํƒ€์ž…์ธ์ง€ ์‹ ๊ฒฝ ์“ฐ์ง€ ์•Š๊ณ  ๊ฑฐ์นจ์—†์ด Expression ํ˜•์‹์˜ ์ฐธ์กฐ๋ฅผ ์„ ์–ธํ•ด์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—๋Š” ๊ฐ ์„ธ๋ถ€ ํ˜•์‹์œผ๋กœ ํ˜•๋ณ€ํ™˜์„ ํ•˜๋ฉด ๋˜๋‹ˆ๊นŒ.
์ด๊ฒƒ์ด ํŒฉํ† ๋ฆฌ ๋ฉ”์†Œ๋“œ ํŒจํ„ด์˜ ๋งค๋ ฅ.

1
2
3
4
5
Expression const1 = Expression.Constant(1);// ์ƒ์ˆ˜ ํ‘œํ˜„์‹ ๊ฐ์ฒด ์ƒ์„ฑ
Expression param1 = Expression.Parameter(typeof(int), "x"); // ๋งค๊ฐœ๋ณ€์ˆ˜ ํ‘œํ˜„์‹ ๊ฐ์ฒด ์ƒ์„ฑ

Expression exp = Expression.Add(const1, param1); // ๋ง์…ˆ ํ‘œํ˜„์‹ ๊ฐ์ฒด ์ƒ์„ฑ
// '1 + x' ๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์‹ ํŠธ๋ฆฌ

๐Ÿซง Expression ์ปดํŒŒ์ผ/์‹คํ–‰

์‹ ํŠธ๋ฆฌ๋Š” ๊ฒฐ๊ตญ โ€œ์‹โ€์„ ํŠธ๋ฆฌ๋กœ ํ‘œํ˜„ํ•œ ๊ฒƒ์— ๋ถˆ๊ณผ.
๋‹ค์‹œ ๋งํ•ด, ์‹คํ–‰ ๊ฐ€๋Šฅํ•œ ์ƒํƒœ๊ฐ€ ์•„๋‹ˆ๋ผ ๊ทธ์ € โ€œ๋ฐ์ดํ„ฐโ€ ์ƒํƒœ์— ๋จธ๋ฌผ๋Ÿฌ ์žˆ๋‹ค๋Š” ๋ง.

์ž์‹ ์˜ ํŠธ๋ฆฌ ์ž๋ฃŒ ๊ตฌ์กฐ ์•ˆ์— ์ •์˜๋˜์–ด ์žˆ๋Š” ์‹์„ ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ์œผ๋ ค๋ฉด ๋žŒ๋‹ค์‹์œผ๋กœ ์ปดํŒŒ์ผ๋˜์–ด์•ผ ํ•œ๋‹ค.

๋žŒ๋‹ค์‹์œผ๋กœ์˜ ์ปดํŒŒ์ผ์€ Expression<TDelegate> ํด๋ž˜์Šค๋ฅผ ์ด์šฉํ•œ๋‹ค.
(Expression <- LambdaExpression <- Expression<TDelegate>)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Expression const1 = Expression.Constant(1);
Expression param1 = Expression.Parameter(typeof(int), "x");

Expression exp = Expression.Add(const1, param1);

// ๋žŒ๋‹ค์‹ LambdaExpression (์ •ํ™•ํžˆ๋Š” ํŒŒ์ƒ ํด๋ž˜์Šค์ธ Expression<TDelegate>) ์ƒ์„ฑ
Expression<Func<int, int>> lambda1 = 
	Expression.Lambda<Func<int, int>>( // ๋ฐ˜ํ™˜๊ฐ’์ด int์ด๊ณ  ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ int์ธ ๋žŒ๋‹ค์‹์„ ๋งŒ๋“ญ๋‹ˆ๋‹ค.
		exp,
		new ParameterExpression[] { (ParameterExpression)param1 });

// ์‹คํ–‰๊ฐ€๋Šฅํ•œ ์ฝ”๋“œ๋กœ ์ปดํŒŒ์ผ
Func<int, int> compiledExp = lambda1.Compile();

// ์ปดํŒŒ์ผ๋œ ๋žŒ๋‹ค์‹์„ ์‹คํ–‰
Console.WriteLine(compiledExp(3)); // Output : 4

๐Ÿซง Expression ๋žŒ๋‹ค์‹ ํ™œ์šฉ

๋žŒ๋‹ค์‹์„ ์ด์šฉํ•˜๋ฉด ๋” ๊ฐ„๋‹จํ•˜๊ฒŒ ์‹ ํŠธ๋ฆฌ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

๋‹ค๋งŒ ์ด ๊ฒฝ์šฐ์—๋Š” โ€œ๋™์ ์œผ๋กœโ€ ์‹ ํŠธ๋ฆฌ๋ฅผ ๋งŒ๋“ค๊ธฐ๋Š” ์–ด๋ ค์›Œ์ง„๋‹ค.
Expression ํ˜•์‹์€ โ€œ๋ถˆ๋ณ€ (Immutable)โ€์ด๊ธฐ ๋•Œ๋ฌธ์—, ํ•œ ๋ฒˆ ์ธ์Šคํ„ด์Šค๋ฅผ ๋งŒ๋“ค๋ฉด ์ˆ˜์ •ํ•  ์ˆ˜ ์—†๋‹ค.

1
2
3
4
Expression<Func<int, int>> lambda2 = (x) => 1 + x;
Func<int, int> compiledExp = lambda2.Compile();

Console.WriteLine(compiledExp(3)); // Output : 4

๐Ÿซง Expression So?

์‹ ํŠธ๋ฆฌ๋Š” ์ฝ”๋“œ๋ฅผ โ€œ๋ฐ์ดํ„ฐโ€๋กœ์จ ๋ณด๊ด€ํ•  ์ˆ˜ ์žˆ๋‹ค.
ํŒŒ์ผ์— ์ €์žฅํ•  ์ˆ˜๋„ ์žˆ๊ณ  ๋„คํŠธ์›Œํฌ๋ฅผ ํ†ตํ•ด ๋‹ค๋ฅธ ํ”„๋กœ์„ธ์Šค์— ์ „๋‹ฌํ•  ์ˆ˜๋„ ์žˆ๋‹ค.

์‹ฌ์ง€์–ด ์ฝ”๋“œ๋ฅผ ๋‹ด๊ณ  ์žˆ๋Š” ์‹ ํŠธ๋ฆฌ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ์ดํ„ฐ ๋ฒ ์ด์Šค ์„œ๋ฒ„์— ๋ณด๋‚ด์„œ ์‹คํ–‰์‹œํ‚ฌ ์ˆ˜๋„ ์žˆ๋‹ค.

๋ฐ์ดํ„ฐ ๋ฒ ์ด์Šค ์ฒ˜๋ฆฌ๋ฅผ ์œ„ํ•œ ์‹ ํŠธ๋ฆฌ๋Š” LINQ์—์„œ ์‚ฌ์šฉ๋œ๋‹ค
LINQ๋ฅผ ์ดํ•ดํ•˜๋ ค๋ฉด ๋žŒ๋‹ค์‹๊ณผ ์‹ ํŠธ๋ฆฌ๋ฅผ ์ดํ•ดํ•˜๊ณ  ์žˆ์–ด์•ผํ•œ๋‹ค.

๐Ÿซง Expression-Bodied Member | ์‹ ๋ณธ๋ฌธ ๋ฉค๋ฒ„

โ€˜๋ฉ”์†Œ๋“œ, ์†์„ฑ(์ธ๋ฑ์„œ), ์ƒ์„ฑ์ž, ์ข…๋ฃŒ์žโ€™์˜ ๊ณตํ†ต๋œ ํŠน์ง•?
๋ชจ๋‘ ํด๋ž˜์Šค์˜ ๋ฉค๋ฒ„๋กœ์„œ ๋ณธ๋ฌธ์ด ์ค‘๊ด„ํ˜ธ๋กœ ๋งŒ๋“ค์–ด์ ธ ์žˆ๋‹ค.

์ด๋Ÿฌํ•œ ๋ฉค๋ฒ„์˜ ๋ณธ๋ฌธ์„ ์‹(Expression)๋งŒ์œผ๋กœ ๊ตฌํ˜„ํ•˜๋Š” ๊ฒƒ์ด ๊ฐ€๋Šฅํ•˜๋‹ค.
๋ฉค๋ฒ„ => ์‹ ํ˜•ํƒœ๋กœ ๊ตฌํ˜„ํ•œ๋‹ค.

์ด๋ ‡๊ฒŒ ์‹์œผ๋กœ ๊ตฌํ˜„๋œ ๋ฉค๋ฒ„๋ฅผ ์‹ ๋ณธ๋ฌธ ๋ฉค๋ฒ„(Expression-Bodied Member)๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class MyClass
{
	private List<int> list = new List<int>();

	// ๋ฉ”์†Œ๋“œ
	public void Add(int value) => list.Add(value);

	// ์ฝ๊ธฐ ์ „์šฉ ์†์„ฑ
	public int Capacity => list.Capacity;

	// ์ฝ๊ธฐ / ์“ฐ๊ธฐ ๊ฐ€๋Šฅํ•œ ์†์„ฑ, ์ธ๋ฑ์„œ [1]
	public int this[int index]
	{
		get => list[index];
		set => list[index] = value;
	}

	// ์ธ๋ฑ์„œ [2]
	public int this[int index] => list[index];

	// ์ƒ์„ฑ์ž, ์ข…๋ฃŒ์ž
	public MyClass(int value) => this.value = value;
	~MyClass() => Console.WriteLine("์†Œ๋ฉธ์ž ํ˜ธ์ถœ");
}

๐Ÿ’ซ ๋ฉ”๋ชจ/์ฐธ๊ณ 


  • ฮป-Expression
  • ฮป๋Š” ๊ทธ๋ฆฌ์Šค ๋ฌธ์ž์—์„œ L์— ํ•ด๋‹นํ•˜๋Š” ๋ฌธ์ž
    • ์•Œ๋ก ์กฐ ์ฒ˜์น˜๋Š” ์ด ๋ฌธ์ž๋ฅผ ํ•จ์ˆ˜ ํ‘œ๊ธฐ๋ฅผ ์œ„ํ•œ ๊ธฐํ˜ธ๋กœ ^๋ฅผ ์‚ฌ์šฉํ–ˆ๋Š”๋ฐ, ์ด๋Š” ํ”„๋ฆฐํ„ฐ์—์„œ ์–ด๋ ค์›€์ด ์žˆ์–ด ฮป๋กœ ๋ฐ”๊ฟจ๋‹ค๊ณ  ํ•จ
  • => ๋ฅผ ํ™”์‚ดํ‘œ ์—ฐ์‚ฐ์ž๋ผ๊ณ ๋„ ๋ถ€๋ฅธ๋‹ค.
    • ์ด ๊ฒฝ์šฐ, => ๋ฅผ ์ด์šฉํ•œ ์‹์„ ํ™”์‚ดํ‘œ ํ•จ์ˆ˜๋ผ๊ณ  ๋ถ€๋ฅธ๋‹ค.
  • โ€˜์ด๊ฒƒ์ด C#์ด๋‹ค.โ€™, โ€˜MSDNโ€™
  • TODO: C# ๋žŒ๋‹ค ํด๋กœ์ € ์›๋ฆฌ

  • TODO: LINQ
  • TODO: ํŒฉํ† ๋ฆฌ ํŒจํ„ด (ํŒฉํ† ๋ฆฌ ๋ฉ”์†Œ๋“œ)
  • TODO: ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋ก ๊ณผ ์—ฐ๊ด€์ง€์–ด (์‹ํŠธ๋ฆฌ)

๐Ÿซง Lambda-Expression ๋ฐฐ๊ฒฝ

์•Œ๋ก ์กฐ ์ฒ˜์น˜(Alonzo Church)
1936๋…„์— ๊ณ ์•ˆํ•œ ๋žŒ๋‹ค ๊ณ„์‚ฐ๋ฒ•(Lambda Calculus : ๋žŒ๋‹ค ๋Œ€์ˆ˜)์—์„œ ์œ ๋ž˜.

  • ๋žŒ๋‹ค ๊ณ„์‚ฐ๋ฒ• :
    • ์ˆ˜ํ•™ ๊ธฐ์ดˆ๋ก ์„ ์—ฐ๊ตฌํ•˜๋˜ ์ค‘, ๋ถ„๋ช…ํ•˜๊ณ  ๊ฐ„๊ฒฐํ•œ ๋ฐฉ๋ฒ•์œผ๋กœ ํ•จ์ˆ˜๋ฅผ ๋ฌ˜์‚ฌํ•˜๊ธฐ ์œ„ํ•ด ๊ณ ์•ˆ
    • ํฌ๊ฒŒ ํ•จ์ˆ˜์˜ ์ •์˜์™€ ๋ณ€์ˆ˜, ๊ทธ๋ฆฌ๊ณ  ํ•จ์ˆ˜์˜ ์ ์šฉ์œผ๋กœ ๊ตฌ์„ฑ
    • ์ด ๊ณ„์‚ฐ๋ฒ•์—์„œ๋Š” ๋ชจ๋“  ๊ฒƒ์ด ํ•จ์ˆ˜๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์Œ, ์‹ฌ์ง€์–ด โ€˜0, 1, 2 โ€ฆโ€™ ๊ฐ™์€ ์ˆซ์ž๋„ ํ•จ์ˆ˜๋กœ ํ‘œํ˜„
    • ๋”ฐ๋ผ์„œ ๋žŒ๋‹ค ๊ณ„์‚ฐ๋ฒ•์—์„œ๋Š” ์–ด๋–ค ๊ฐ’์„ ๋ณ€์ˆ˜์— ๋Œ€์ž…ํ•˜๊ณ  ์‹ถ์œผ๋ฉด ํ•จ์ˆ˜๋ฅผ ๋ณ€์ˆ˜์— ๋Œ€์ž…ํ•˜๋ฉฐ, ์ด๊ฒƒ์„ ํ•จ์ˆ˜์˜ ์ ์šฉ์ด๋ผ๊ณ  ๋ถ€๋ฆ„

์ œ์ž์˜€๋˜ ์กด ๋งค์นด์‹œ(John McCarthy).
์ด๊ฒƒ์„ ๋‹จ์ˆœํžˆ ์ˆ˜ํ•™ ์ด๋ก ์— ๊ทธ์น˜์ง€ ์•Š๊ณ , ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์— ๋„์ž…ํ•  ์ˆ˜ ์žˆ๊ฒ ๋‹ค๋Š” ์•„์ด๋””์–ด๋ฅผ ์ œ์‹œ.
50๋…„๋Œ€ ๋ง์— LISP๋ผ๋Š” ์–ธ์–ด๋ฅผ ๊ฐœ๋ฐœ.

์ดํ›„ ๋žŒ๋‹ค ๊ณ„์‚ฐ๋ฒ•์˜ ๊ฐœ๋…์€ ์ดํ›„ ๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์—๋„ ๋„์ž…๋˜์—ˆ์œผ๋ฉฐ,
C#, C++, Java, Python ๊ฐ™์€ ์ฃผ๋ฅ˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋Š” ๋Œ€๋ถ€๋ถ„ ๋žŒ๋‹ค์‹์„ ์ง€์›.

์ด ๊ธฐ์‚ฌ๋Š” ์ €์ž‘๊ถŒ์ž์˜ CC BY 4.0 ๋ผ์ด์„ผ์Šค๋ฅผ ๋”ฐ๋ฆ…๋‹ˆ๋‹ค.