어나니머스 함수
Anonymous function컴퓨터 프로그래밍에서 익명 함수(함수 리터럴, 람다 추상화, 람다 함수, 람다 식 또는 블록)는 식별자에 바인딩되지 않은 함수 정의입니다.어나니머스 함수는 종종 상위 함수에 전달되거나 [1]함수를 반환해야 하는 상위 함수의 결과를 구성하기 위해 사용되는 인수입니다.함수를 한 번만 또는 제한된 횟수만 사용하는 경우 익명 함수는 명명된 함수를 사용하는 것보다 구문적으로 가벼울 수 있습니다.어나니머스 함수는 기능 프로그래밍 언어 및 퍼스트 클래스 함수를 가진 다른 언어에서 흔히 볼 수 있으며, 여기서 리터럴이 다른 데이터 유형에 대해 수행하는 것과 동일한 역할을 수행합니다.
익명의 함수는 알론조 교회가 1936년 람다 미적분을 발명하면서 시작되었다.람다 미적분에서는 모든 함수가 익명으로 되어 있으며, 전자계산기 이전이다.[2] 몇몇 프로그래밍 언어에서 익명 함수는 키워드 lamda를 사용하여 도입되며, 익명 함수는 종종 lamdas 또는 lamda 추상화라고 불립니다.1958년 리스프 이후 익명 함수가 프로그래밍 언어의 특징이며, 익명 함수를 지원하는 현대 프로그래밍 언어가 증가하고 있습니다.
이름
"라다 추상화", "라다 함수", "라다 식"이라는 이름은 람다 미적분학의 함수 추상화 표기법에서 일반적인 함수 f(x) = M이 기록될 것이다.M) (M은 x를 사용하는 식입니다.)의 Python 구문과 비교해 보십시오.lambda x: M.
"화살표 함수"라는 이름은 수학적인 "맵 대상" 기호인 x m M을 나타냅니다.의 JavaScript 구문과 비교해 보십시오.x => M를 클릭합니다.[3]
사용하다
 |
익명 함수는 이름이 필요 없는 기능을 포함하거나 단기간에 사용할 수 있습니다.몇몇 주목할 만한 예로는 클로징과 카레링이 있다.
익명 기능의 사용은 스타일의 문제입니다.이러한 함수를 사용하는 것만이 문제를 해결할 수 있는 유일한 방법은 아닙니다.각 익명 함수는 이름 있는 함수로 정의되어 이름으로 호출될 수 있습니다.일부 프로그래머는 익명 함수를 사용하여 재사용 불가능한 특정 코드를 캡슐화하고 많은 한 줄의 일반 함수와 함께 코드를 폐기하지 않습니다.
일부 프로그래밍 언어에서 익명 함수는 일반적으로 콜백에 대한 이벤트 바인딩이나 특정 값에 대한 함수 인스턴스화 등 매우 특정한 목적을 위해 구현됩니다.이러한 함수는 보다 일반적이고 이름 있는 함수를 호출하는 것보다 더 효율적이고 읽기 쉬우며 오류 발생 가능성이 적을 수 있습니다.
다음 예는 Python 3에 기재되어 있습니다.
정렬
비표준적인 방법으로 정렬을 시도할 경우 명명된 함수를 만드는 대신 정렬 로직을 익명 함수로 포함하는 것이 더 쉬울 수 있습니다.대부분의 언어는 임의의 개체를 정렬하는 정렬 알고리즘을 구현하는 일반 정렬 함수를 제공합니다.이 함수는 보통 두 요소가 동일한지 또는 한 요소가 다른 요소보다 크거나 작은지를 비교하는 방법을 결정하는 임의 함수를 받아들입니다.
문자열의 길이를 기준으로 문자열 목록을 정렬하는 다음 Python 코드를 고려하십시오.
>>> a = ['하우스', 카, '자전거] >>> a.종류(열쇠=람다 x: 렌(x)) >>> a [카, '자전거, '하우스'] 이 예에서 익명 함수는 람다 식입니다.
람다 x: 렌(x) anonymous 함수는 하나의 인수를 받아들입니다.x인수의 길이를 반환합니다.이 길이는 에 의해 사용됩니다.sort()method를 정렬 기준으로 사용합니다.
Python에서 람다 함수의 기본 구문은 다음과 같습니다.
람다 arg1, arg2, arg3, ...: < >작동 에 그 논쟁들 돌아오는 a 가치> 람다 함수에 의해 반환되는 식은 변수에 할당되어 코드에서 여러 위치에 사용할 수 있습니다.
>>> 더하다 = 람다 a: a + a >>> 더하다(20) 40 다른 예로는 목록의 항목을 클래스 이름으로 정렬하는 경우가 있습니다(Python에서는 모든 항목에 클래스가 있습니다).
>>> a = [10, '숫자', 11.2] >>> a.종류(열쇠=람다 x: x.__class__.__name__) >>> a [11.2, 10, '숫자'] 주의:11.2클래스 이름 "을 가지고 있습니다.float",10클래스 이름 "을 가지고 있습니다.int", 및'number'클래스 이름 "을 가지고 있습니다.str". 정렬된 순서는 " 입니다.float", "int"그럼"str".
폐쇄
폐쇄는 경계 변수를 포함하는 환경에서 평가되는 함수입니다.다음 예제에서는 입력을 임계값과 비교하는 어나니머스 함수로 변수 "임계값"을 바인딩합니다.
방어하다 컴포넌트(문턱값): 돌아가다 람다 x: x < > 문턱값 이는 일종의 비교 함수 생성기로 사용할 수 있습니다.
>>> 기능 = 컴포넌트(10) >>> 기능 = 컴포넌트(20) >>> 인쇄물(기능(5), 기능(8), 기능(13), 기능(21)) 진실의 진실의 거짓의 거짓의 >>> 인쇄물(기능(5), 기능(8), 기능(13), 기능(21)) 진실의 진실의 진실의 거짓의 가능한 모든 비교 함수에 대해 함수를 만드는 것은 비현실적이며, 더 이상 사용하기 위해 임계값을 유지하는 것이 너무 불편할 수 있습니다.폐쇄를 사용하는 이유에 관계없이 익명 함수는 비교를 수행하는 기능을 포함하는 엔티티입니다.
카레잉
커링은 함수를 변경하여 여러 입력을 받는 것이 아니라 하나의 입력을 받고 두 번째 입력을 받는 함수를 반환하는 과정입니다.이 예에서는 임의의 정수로 나눗셈을 수행하는 함수가 설정된 정수로 나눗셈을 수행하는 함수로 변환됩니다.
>>> 방어하다 나누다(x, y): ... 돌아가다 x / y >>> 방어하다 제수(d): ... 돌아가다 람다 x: 나누다(x, d) >>> 반 = 제수(2) >>> 셋째 = 제수(3) >>> 인쇄물(반(32), 셋째(32)) 16.0 10.666666666666666 >>> 인쇄물(반(40), 셋째(40)) 20.0 13.333333333333334 카레링에서는 익명의 기능을 사용하는 것이 일반적이지 않을 수 있지만 여전히 사용할 수 있습니다.위의 예에서 함수 제수는 지정된 제수를 사용하여 함수를 생성합니다.함수의 절반과 세 번째가 나눗셈 함수를 고정 제수로 커리링합니다.
또한 제수 함수는 변수를 바인딩하여 닫힘을 형성합니다.d.
고차 함수
고차 함수는 함수를 인수로 사용하는 함수입니다.이것은 일반적으로 일반적으로 정의된 함수(종종 루프 구성 또는 재귀 방식)의 동작을 사용자 정의하기 위해 사용됩니다.익명 함수는 이러한 함수 인수를 지정하는 편리한 방법입니다.다음은 Python 3의 예입니다.
지도
맵 함수는 목록의 각 요소에 대해 함수 호출을 수행합니다.다음 예제에서는 익명 함수를 사용하여 배열의 모든 요소를 제곱합니다.
>>> a = [1, 2, 3, 4, 5, 6] >>> 목록.(지도(람다 x: x*x, a)) [1, 4, 9, 16, 25, 36] 어나니머스 함수는 인수를 받아들이고 인수를 직접 곱합니다(제곱).위의 형식은 아래에 제시된 형식이 동일한 의미를 가지며 언어의 철학과 더 일치한다고 주장하는 언어 창작자들에 의해 권장되지 않습니다.
>>> a = [1, 2, 3, 4, 5, 6] >>> [x*x 위해서 x 에 a] [1, 4, 9, 16, 25, 36] 필터
필터 함수는 특정 함수에 전달되었을 때 True를 평가하는 목록의 모든 요소를 반환합니다.
>>> a = [1, 2, 3, 4, 5, 6] >>> 목록.(필터(람다 x: x % 2 == 0, a)) [2, 4, 6] 어나니머스 함수는 전달된 인수가 짝수인지 여부를 확인합니다.지도와 마찬가지로 다음 형식이 더 적절하다고 간주됩니다.
>>> a = [1, 2, 3, 4, 5, 6] >>> [x 위해서 x 에 a 한다면 x % 2 == 0] [2, 4, 6] 접다
폴드 함수는 구조체의 모든 요소에 걸쳐 실행됩니다(일반적으로 왼쪽에서 오른쪽으로 나열되는 목록의 경우 "왼쪽 폴드"라고 함).reducePython에서) 값을 축적합니다.예를 들어 다음과 같이 구조물의 모든 요소를 하나의 값으로 결합할 수 있습니다.
>>> 부터 기능하다 수입품 줄이자 >>> a = [1, 2, 3, 4, 5] >>> 줄이자(람다 x,y: x*y, a) 120 이 동작은
여기서 어나니머스 함수는 두 인수를 곱한 것입니다.
폴드의 결과는 하나의 값일 필요는 없습니다.대신, 지도와 필터를 모두 접어서 만들 수 있습니다.맵에서 누적되는 값은 원래 목록의 각 요소에 함수를 적용한 결과를 포함하는 새 목록입니다.필터에서 누적되는 값은 지정된 조건과 일치하는 요소만 포함하는 새 목록입니다.
언어 목록
다음은 이름 없는 어나니머스 함수를 완전히, 또는 일부 변형으로 또는 전혀 지원하지 않는 프로그래밍 언어 목록입니다.
이 표는 몇 가지 일반적인 경향을 보여줍니다.첫째, 익명 함수(C, Pascal, Object Pascal)를 지원하지 않는 언어는 모두 정적으로 입력된 언어입니다.단, 정적으로 입력된 언어는 익명 기능을 지원할 수 있습니다.예를 들어 ML 언어는 정적으로 입력되며 기본적으로 익명 함수를 포함하며 오브젝트 파스칼의 방언인 델파이는 C++(C++11 표준에 따라)와 마찬가지로 익명 함수를 지원하도록 확장되었습니다.둘째, 함수를 퍼스트 클래스 함수로 취급하는 언어(Dylan, Haskell, JavaScript, Lisp, ML, Perl, Python, Ruby, Scheme)는 일반적으로 익명 함수를 지원하므로 함수를 다른 데이터 유형만큼 쉽게 정의하고 전달할 수 있습니다.
 |
| 언어 | 지지하다 | 메모들 |
|---|---|---|
| 액션 스크립트 |  | |
| 아다 |  | 표현 함수는 Ada2012의 일부입니다. |
| 알골 68 | | |
| APL | | Dyalog, ngn 및 dzaima APL은 dfns 및 암묵 기능을 모두 완전히 지원합니다.GNU APL은 dfns에 대한 지원이 다소 제한되어 있습니다. |
| 어셈블리 언어 | | |
| 배쉬 | | Bash에서 [4]익명 기능을 지원하기 위해 라이브러리가 만들어졌습니다. |
| C | | 지원은 Clang 및 LLVM 컴파일러-rt lib와 함께 제공됩니다.GCC는 사용 가능성을 가능하게 하는 매크로 구현에 대해 지원됩니다.자세한 것은, 이하를 참조해 주세요. |
| C# | | [5] |
| C++ | | C++11 기준 |
| CFML | | Railo [6]4, ColdFusion 10[7] 현재 |
| 클로쥬르 | | [8] |
| 코볼 | | Micro Focus의 비표준 Managed COBOL 방언은 익명 위임/[9]메서드라고 하는 람다를 지원합니다. |
| 컬 | | |
| D | | [10] |
| 다트 | | [11] |
| 델파이 | | [12] |
| 딜런 | | [13] |
| 에펠 | | |
| 느릅나무 | | [14] |
| 엘릭시르 | | [15] |
| 얼랑 | | [16] |
| F# | | [17] |
| 엑셀 | | Excel 워크시트 기능, 2021 베타[18] 릴리즈 |
| 요인 | | 이를 뒷받침하는[19] '인용' |
| 포트란 | | |
| 프링크 | | [20] |
| 가세요 | | [21] |
| 고수 | | [22] |
| 그루비 | | [23] |
| 하스켈 | | [24] |
| Haxe | | [25] |
| 자바 | | Java 8에서 지원됩니다.상세한 것에 대하여는, 다음의 「Java 제한」섹션을 참조해 주세요. |
| 자바스크립트 | | [26] |
| 줄리아. | | [27] |
| 코틀린 | | [28] |
| 리스프 | | |
| 로그토크 | | |
| 루아 | | [29] |
| 유행성 이하선염 | | |
| 메이플 | | [30] |
| 매트랩 | | [31] |
| 막시마 | | [32] |
| 님 | | [33] |
| OCaml | | [34] |
| 옥타브 | | [35] |
| 오브젝트 파스칼 | | 오브젝트 파스칼의 방언인 델파이는 델파이의 2009년 이후 기본적으로 익명 함수(공식적으로 익명 메서드)를 지원합니다.옥시진 오브젝트 파스칼 방언도 이들을 지원합니다. |
| Objective-C(Mac OS X 10.6+) | | Called blocks. Objective-C 외에 Apple 플랫폼에서 프로그래밍할 때 C 및 C++에서도 블록을 사용할 수 있습니다. |
| OpenSCAD | | Function Literal 지원은 2021.[36]01 버전에서 도입되었습니다. |
| 파스칼 | | |
| 펄 | | [37] |
| PHP | | PHP 5.3.0에서는 진정한 익명 함수가 지원됩니다.[38]이전에는 부분적인 익명 함수만 지원되었으며, 이는 C#의 구현과 매우 유사했습니다. |
| PL/I | | |
| 파이썬 | | Python은 문이 아닌 식만 지원하는 lambda [39]구문을 통해 익명 함수를 지원합니다. |
| R | | |
| 라켓 | | [40] |
| 라쿠 | | [41] |
| 렉시 | | |
| RPG | | |
| 루비 | | Smalltalk에서 물려받은 Ruby의 익명 기능은 블록이라고 [42]불립니다. |
| 녹 | | [43] |
| 스칼라 | | [44] |
| 스킴 | | |
| 스몰토크 | | Smalltalk의 익명 기능은 블록이라고 불립니다. |
| 표준 ML | | [45] |
| 재빠르다 | | 스위프트의 익명 기능은 Closures라고 불립니다.[46] |
| 타입 스크립트 | | [47] |
| TCL | | [48] |
| 바라 | | [48] |
| Visual Basic.NET v9 | | [49] |
| Visual Prolog v 7.2 | | [50] |
| 울프람어 | | [51] |
예
 |
많은 언어가 익명 기능 또는 유사한 기능을 지원합니다.
APL
일부 방언만이 dfns로서, 암묵적인 스타일 또는 그 양쪽의 조합으로 익명 기능을 지원합니다.
f←{⍵×⍵} § dfn으로서 f 1 2 3 1 4 9 g←⊢×⊢ ② 암묵적인 3열차로 (포크) g 1 2 3 1 4 9 h←×⍨ ② 유도 암묵함수로서 h 1 2 3 1 4 9 C(비표준 내선번호)
어나니머스 함수는 표준 C 프로그래밍 언어에서는 지원되지 않지만 GCC[52] 및 Clang 등의 일부 C 방언에서는 지원됩니다.
GCC
GCC(GNU 컴파일러 컬렉션)는 중첩된 함수와 문 표현식이 혼합된 익명 함수를 지원합니다.다음과 같은 형식이 있습니다.
( { return_type(반환형) anonymous_module_name (파라미터) { 기능_바디 } anonymous_module_name; } ) 다음으로 GCC에서만 동작하는 예를 나타냅니다.매크로가 확장되는 방식에 따라l_body괄호 밖에 콤마를 포함할 수 없습니다.GCC는 콤마를 매크로 인수 사이의 딜리미터로 취급합니다.의론l_ret_type만약 그렇다면 제거될 수 있다__typeof__를 사용할 수 있습니다.다음 예에서는 를 사용합니다.__typeof__어레인지로 되돌아가다testtype *필요한 경우 실제 값을 참조할 수 있습니다.
#실패하다 <stdio.h> //* 어나니머스 함수의 정의 */ #caps lamda(l_ret_type, l_caps, l_body) \ ({ \ l_ret_type l_syslog_name l_syslog \ l_body \ &l_syslog_name; \ }) #EachInArray 정의(fe_arrType, fe_arr, fe_fn_body) \ { \ int i=0; \ (;i<sizeof(fe_arr)/sizeof(fe_arType);i++) {fe_arr[i] = fe_fn_body(&fe_arr[i]), } \ } 유형화된 구조 { 인트 a; 인트 b; } 테스트 타이프; 무효 인쇄하다.(컨스턴트 테스트 타이프 * 배열) { 인트 i; 위해서 ( i = 0; i < > 3; ++ i ) 인쇄물(%d %d\n", 배열[i].a, 배열[i].b); 인쇄물("\n"); } 인트 주된(무효) { 테스트 타이프 배열[] = { {0,1}, {2,3}, {4,5} }; 인쇄하다.(배열); /* 익명 함수는 foreach*/의 함수로 제공됩니다. Each In Array의 경우(테스트 타이프, 배열, 람다 (테스트 타이프, (무효 *아이템), { 인트 임시직 = (*( 테스트 타이프 *) 아이템).a; (*( 테스트 타이프 *) 아이템).a = (*( 테스트 타이프 *) 아이템).b; (*( 테스트 타이프 *) 아이템).b = 임시직; 돌아가다 (*( 테스트 타이프 *) 아이템); })); 인쇄하다.(배열); 돌아가다 0; } Clang (C, C++, Objective-C, Objective-C++)
Clang은 다음과 같은 형식의 [53]블록이라는 익명 함수를 지원합니다.
^return_type(반환형) ( 파라미터 ) { 기능_바디 } 위의 블록 유형은return_type (^)(parameters).
앞서 설명한 블록 확장과 Grand Central Dispatch(lib dispatch)를 사용하면 코드가 더 단순해 보일 수 있습니다.
#실패하다 <stdio.h> #실패하다 <contraction/contractions.h> 인트 주된(무효) { 무효 (^count_loop)() = ^{ 위해서 (인트 i = 0; i < > 100; i++) 인쇄물(%d\n", i); 인쇄물("아아아아아아아아'\n"); }; /* 다른 함수에 매개 변수로 전달 */ dispatch_dispatchc(dispatch_get_global_dispatch(DISPATCH_QUUE_PRIORITY_DEFAULT, 0), count_loop); /* 직접 호출 */ count_loop(); 돌아가다 0; } 블록이 있는 코드는 다음과 같이 컴파일해야 합니다.-fblocks와 연계되어 있습니다.-lBlocksRuntime
C++(C++11 이후)
C++11은 다음과 같은 형식의 람다 [54]식이라고 하는 익명 함수를 지원합니다.
[포획.](파라미터) -> return_type(반환형) { 기능_바디 } 다음은 람다 표현의 예를 보여드리겠습니다.
[](인트 x, 인트 y) { 돌아가다 x + y; } C++11은 클로저(여기에서는 캡처라고 부릅니다)도 지원합니다.캡처는 대괄호 사이에 정의됩니다.[그리고.]람다 발현 선언에서.이 메커니즘을 통해 값 또는 참조로 이러한 변수를 캡처할 수 있습니다.다음 표에 이를 나타냅니다.
[] // 캡처 없음, 람다는 함수의 포인터로 암묵적으로 변환할 수 있습니다. [x, &y] // x 는 값으로 캡처되고 y 는 참조로 캡처됩니다. [&] // 외부 변수가 사용될 경우 참조에 의해 암묵적으로 캡처됩니다. [=] // 외부 변수는 사용되는 경우 값에 의해 암묵적으로 캡처됩니다. [&, x] // x 는 값으로 캡처됩니다.다른 변수는 참조에 의해 캡처됩니다. [=, &z] // z는 참조로 캡처됩니다.다른 변수는 값으로 캡처됩니다. 값으로 캡처되는 변수는 기본적으로 일정합니다.추가 중mutable파라미터 리스트가 비패킷이 된 후.
C++14 이후 버전은 다음과 같이 init-capture를 지원합니다.
표준::unique_ptr< >인트> ptr = 표준::make_filengths< >인트>(42); [ptr]{ /* ... */ }; // 고유 포인터에 대한 복사 할당이 삭제되었습니다. [ptr = 표준::움직이다(ptr)]{ /* ... */ }; // OK(확인) 자동 계산대 = [i = 0]() 변이 가능한 { 돌아가다 i++; }; // 'i'를 수정하려면 변환 가능이 필요합니다. 계산대(); // 0 계산대(); // 1 계산대(); // 2 다음 두 가지 예제에서는 람다 식을 사용하는 방법을 보여 줍니다.
표준::벡터< >인트> 일부_리스트{ 1, 2, 3, 4, 5 }; 인트 총 = 0; 표준::각각(시작한다.(일부_리스트), 끝.(일부_리스트), [&총](인트 x) { 총 += x; }); // 표준::누적이 여기서 더 나은 대안이 될 수 있습니다. 목록 내 모든 요소의 합계가 계산됩니다.변수total람다 함수의 폐쇄의 일부로 저장됩니다.스택 변수에 대한 참조이므로total, 값을 변경할 수 있습니다.
표준::벡터< >인트> 일부_리스트{ 1, 2, 3, 4, 5 }; 인트 총 = 0; 인트 가치 = 5; 표준::각각(시작한다.(일부_리스트), 끝.(일부_리스트), [&총, 가치, 이것.](인트 x) { 총 += x * 가치 * 이것.->some_func(); }); 이로 인해total참고용으로 저장되기는 하지만value복사본으로 저장됩니다.
의 캡처this특별합니다.참조가 아닌 값으로만 캡처할 수 있습니다.단, C++17에서는 현재 오브젝트를 값으로 캡처할 수 있습니다(다음으로 나타냅니다).*this또는 참조로 캡처할 수 있습니다(참조:this).this는 가장 가까운 포위 함수가 비정적 멤버 함수인 경우에만 캡처할 수 있습니다.람다는 보호된 멤버/개인 멤버 측면에서 람다를 만든 멤버와 동일한 액세스 권한을 가집니다.
한다면this명시적 또는 암묵적으로 캡처된 후 폐쇄된 클래스 멤버의 범위도 테스트됩니다.멤버 액세스this명시적으로 사용할 필요가 없다this->구문을 사용합니다.
특정 내부 구현은 다를 수 있지만, 모든 것을 참조로 캡처하는 람다 함수는 스택 변수에 대한 개별 참조가 아니라 생성된 함수의 실제 스택 포인터를 저장합니다.그러나 대부분의 람다 함수는 크기가 작고 범위가 국소적이기 때문에 인라이닝의 후보가 될 가능성이 높기 때문에 참조를 위한 추가 저장소가 필요하지 않습니다.
로컬 변수에 대한 참조를 포함하는 폐쇄 객체가 생성된 가장 안쪽 블록 범위 후에 호출되는 경우 동작이 정의되지 않습니다.
람다 함수는 구현에 의존하는 유형의 함수 객체입니다. 이 유형의 이름은 컴파일러에서만 사용할 수 있습니다.사용자가 람다 함수를 매개 변수로 사용하려는 경우 매개 변수 유형은 템플릿 유형이거나std::function또는 람다 값을 캡처하는 유사한 객체입니다.의 사용방법auto키워드는 람다 함수를 저장하는 데 도움이 됩니다.
자동 my_buffda_func = [&](인트 x) { /*...*/ }; 자동 my_onheap_hibda_func = 신규 자동([=](인트 x) { /*...*/ }); 다음은 변수, 벡터 및 배열에 익명 함수를 저장하고 이름 있는 매개 변수로 전달하는 예를 보여 줍니다.
#실패하다 <기능> #실패하다 <iostream> #실패하다 <blocks> 이중으로 하다 평가하다(표준::기능.< >이중으로 하다(이중으로 하다)> f, 이중으로 하다 x = 2.0) { 돌아가다 f(x); } 인트 주된() { 표준::기능.< >이중으로 하다(이중으로 하다)> f0 = [](이중으로 하다 x) { 돌아가다 1; }; 자동 f1 = [](이중으로 하다 x) { 돌아가다 x; }; 타이프 해제(f0) fa[3] = {f0, f1, [](이중으로 하다 x) { 돌아가다 x * x; }}; 표준::벡터< >타이프 해제(f0)> fv = {f0, f1}; fv.푸시백([](이중으로 하다 x) { 돌아가다 x * x; }); 위해서 (size_t i = 0; i < > fv.크기(); i++) { 표준::외치다 << > fv[i](2.0) << > 표준::끝; } 위해서 (size_t i = 0; i < > 3; i++) { 표준::외치다 << > fa[i](2.0) << > 표준::끝; } 위해서 (자동& f : fv) { 표준::외치다 << > f(2.0) << > 표준::끝; } 위해서 (자동& f : fa) { 표준::외치다 << > f(2.0) << > 표준::끝; } 표준::외치다 << > 평가하다(f0) << > 표준::끝; 표준::외치다 << > 평가하다(f1) << > 표준::끝; 표준::외치다 << > 평가하다([](이중으로 하다 x) { 돌아가다 x * x; }) << > 표준::끝; } 캡처 사양이 비어 있는 람다 식([])는 람다가 선언한 것과 동일한 유형의 함수 포인터로 암묵적으로 변환할 수 있습니다.이것은 합법입니다.
자동 a_sqda_func = [](인트 x) { /*...*/ }; 무효 (* 펑크_ptr)(인트) = a_sqda_func; 펑크_ptr(4); //람다를 굽습니다. C++23에서 시작하여 람다 식은 명시적 표현을 통해 재귀적일 수 있습니다.this첫 번째 파라미터로서:
자동 파이보나치 = [](이것. 자동 자신, 인트 n) { 돌아가다 n <=> 1 ? n : 자신(n - 1) + 자신(n - 2); }; 파이보나치(7); // 13 부스트 라이브러리는 다음 [55]구문을 사용하여 람다 함수에 대한 자체 구문도 제공합니다.
각각(a.시작한다.(), a.끝.(), 표준::외치다 << > _1 << > ' '); C#
C#에서는 언어 컴파일러의 다양한 버전을 통해 익명 함수에 대한 지원이 심화되었습니다.언어 v3.0은 에서 2007년 11월에 출시되었습니다.NET Framework v3.5는 익명 기능을 완전히 지원합니다.C#는 익명 함수의 원래 버전인 람다 [56]미적분을 따라 람다 식을 명명합니다.
// 첫 번째 int는 x' 유형입니다. // 두 번째 int는 반환 유형입니다. // <href="http://msdn.microsoft.com/en-us/library/bb549151.aspx" 참조 />Func<int,int> foo = x => x * x;Console.WriteLine(foo(7));
함수가 익명인 동안 함수는 암묵적으로 입력된 변수에 할당될 수 없습니다. 왜냐하면 람다 구문은 익명 함수 또는 식 트리를 나타내기 위해 사용될 수 있고 컴파일러에 의해 선택이 자동으로 결정될 수 없기 때문입니다.예를 들어, 다음과 같이 동작하지 않습니다.
// 컴파일되지 않습니다! 변화하다 후우 = (인트 x) => x * x; 그러나 람다 식은 유형 추론에 참여할 수 있으며 방법 인수로 사용할 수 있습니다. 예를 들어, 다음과 같이 사용할 수 있는 맵 기능을 가진 익명 함수를 사용하는 경우System.Collections.Generic.List(내ConvertAll()방법):
// 목록 초기화: 변화하다 가치 = 신규 목록.< >인트>() { 7, 13, 4, 9, 3 }; // 목록의 모든 요소에 익명 함수를 매핑하고 새 목록을 반환합니다. 변화하다 후우 = 가치.모두 변환(d => d * d) ; // foo 변수의 결과는 System 유형입니다.컬렉션포괄적인.리스트 <Int32> 이전 버전의 C#에서는 익명 기능에 대한 지원이 더 제한되었습니다.C# v1.0은 2002년2월에 에 도입되었습니다.NET Framework v1.0은 대리인을 통해 부분적인 익명 기능을 지원했습니다.이 구성은 PHP 위임과 다소 유사합니다.C# 1.0에서 위임은 클래스 내에서 명시적으로 명명된 메서드를 참조하는 함수 포인터와 같습니다(단, PHP와 달리 위임 사용 시 이름은 필요하지 않습니다).C# v2.0, 2005년 11월에 출시되었습니다.NET Framework v2.0에서는 위임 호출로 실행할 수 있는 이름 없는 인라인 스테이트먼트 블록을 쓰는 방법으로 익명 메서드의 개념이 도입되었습니다.C# 3.0은 이러한 구성 요소를 계속 지원하지만 람다 표현식 구성도 지원합니다.
이 예에서는 C# 3.0으로 컴파일하여 다음 3가지 형식을 나타냅니다.
일반의 학급 테스트 드라이버 { 위임하다 인트 SquareDe(인트 d); 정적인 인트 광장(인트 d) { 돌아가다 d * d; } 정적인 무효 주된(스트링[] args) { // C# 1.0: 원래 위임 구문 필요 // 명명된 메서드로 초기화 중입니다. SquareDe A = 신규 SquareDe(광장); 시스템..콘솔.기입선(A(3)); // C# 2.0: 대리자를 초기화할 수 있습니다. // 인라인 코드, "inline method"라고 불립니다.이것. // 메서드는 int를 입력 파라미터로 사용합니다. SquareDe B = 위임하다(인트 d) { 돌아가다 d * d; }; 시스템..콘솔.기입선(B(5)); // C# 3.0.대리인은 다음과 같이 초기화할 수 있습니다. // 람다 식입니다.lamda는 int를 받아 int를 반환합니다. // x 의 유형은 컴파일러에 의해 추론됩니다. SquareDe C = x => x * x; 시스템..콘솔.기입선(C(7)); // C# 3.0.1개의 입력을 받아 들이는 대리인 // Func <>타입으로 암묵적으로 선언할 수 있는 출력이 1개 반환됩니다. 시스템..펑크< >인트,인트> D = x => x * x; 시스템..콘솔.기입선(D(9)); } } C# 2.0 버전의 경우 C# 컴파일러는 어나니머스 함수의 코드 블록을 가져와 스태틱프라이빗 함수를 만듭니다.내부적으로는 물론 함수가 생성된 이름을 가져옵니다.이 생성된 이름은 위임자가 선언된 메서드의 이름을 기반으로 합니다.그러나 이름은 반사를 사용하지 않는 한 애플리케이션 코드에 노출되지 않습니다.
C# 3.0 버전의 경우 동일한 메커니즘이 적용됩니다.
ColdFusion Markup Language(CFML)
키워드 사용:
fn = 기능.(){ // 문 }; 화살표 기능을 사용할 수도 있습니다.
fn = () => { // 문 }; fn = () => 단일 표현 // singleExpression 은 암묵적으로 반환됩니다.bracket 또는 return 키워드는 필요 없습니다. fn = 싱글 패램 => { // 화살표 함수에 파라미터가 1개뿐이라면 괄호는 필요 없습니다. // 문 } fn = (x, y) => { // 화살표 기능에 0 또는 여러 파라미터가 있는 경우 괄호를 사용해야 합니다. // 문 } CFML은 단순한 식이 아니라 함수 정의 내의 모든 문을 지원합니다.
CFML은 재귀 어나니머스 함수를 지원합니다.
요인 = 기능.(n){ 돌아가다 n > 1 ? n * 요인(n-1) : 1; }; CFML 어나니머스 함수는 클로저를 구현합니다.
D
D는 인라인 위임자를 사용하여 익명 기능을 구현합니다.인라인 위임의 완전한 구문은 다음과 같습니다.
return_type(반환형) 위임하다(논쟁들){/*본문*/} 명확할 경우 반환 유형과 키워드 delegate를 생략할 수 있습니다.
(x){돌아가다 x*x;} 위임하다 (x){돌아가다 x*x;} // 더 자세한 내용이 필요한 경우 (인트 x){돌아가다 x*x;} // 파라미터 유형을 유추할 수 없는 경우 위임하다 (인트 x){돌아가다 x*x;} // ditto (반복) 위임하다 이중으로 하다(인트 x){돌아가다 x*x;} // 반환 유형을 수동으로 강제해야 하는 경우 버전 2.0 이후 D는 컴파일러가 불필요함을 증명하지 않는 한 힙에 클로저를 할당합니다.scope스택 할당을 강제하기 위해 키워드를 사용할 수 있습니다.버전 2.058 이후로는 다음과 같은 단축 표기법을 사용할 수 있습니다.
x => x*x; (인트 x) => x*x; (x,y) => x*y; (인트 x, 인트 y) => x*y; 익명 함수는 변수에 할당되어 다음과 같이 사용할 수 있습니다.
자동 스쿠르 = (이중으로 하다 x){돌아가다 x*x;}; 이중으로 하다 y = 스쿠르(4); 다트
변화하다 스쿠르 = (x) => x * x; 인쇄물(스쿠르(5)); 또는
인쇄물(((x) => x * x)(5)); 델파이
델파이는 2009 버전에서 익명 기능을 도입했습니다.
프로그램. 데모; 유형 TSimple 절차 = 언급 로. 절차.; TS Imple 기능 = 언급 로. 기능.(컨스턴트 x: 스트링): 정수; 변화하다 x1: TSimple 절차; y1: TS Imple 기능; 시작한다. x1 := 절차. 시작한다. 쓰기('Hello World'); 끝.; x1; //익명의 메서드가 방금 정의되었습니다. y1 := 기능.(컨스턴트 x: 스트링): 정수 시작한다. 결과 := 길이(x); 끝.; 쓰기(y1('바')); 끝.. 파스칼 ABC그물
파스칼 ABCNET은 람다 구문을 사용하여 익명 함수를 지원합니다.
시작한다. 변화하다 n := 10000000; 변화하다 pp := 범위(1,n) .선택한다.(x->인식(랜덤(),랜덤())) .어디에(p->스쿠르(p.항목 1)+스쿠르(p.아이템2)< >1) .세어보세요/n*4; 인쇄(pp); 끝.. 엘릭시르
Elixir는 클로저를 사용합니다. fn사용할 [15]수 있습니다.
합 = fn(a, b) -> a + b 끝. 합.(4, 3) #=> 7 광장 = fn(x) -> x * x 끝. 열거형.지도 [1, 2, 3, 4], 광장 #=> [1, 4, 9, 16] 얼랑
Erlang은 이름 있는 [16]함수와 유사한 어나니머스 함수의 구문을 사용합니다.
제곱 변수에 바인딩된 익명 함수(%) 광장 = 재밌어요(X) -> X * X 끝.. 동일한 기능을 가진 명명된 기능(%) 광장(X) -> X * X. 가세요
후우 := 기능하다(x 인트) 인트 { 돌아가다 x * x } fmt.인쇄(후우(10)) 하스켈
Haskell은 익명 함수(lambda 식)에 간결한 구문을 사용합니다.백슬래시는 λ과 비슷하다고 합니다.
\x -> x * x 람다 표현식은 유형 추론 엔진과 완전히 통합되어 "일반" 함수의 구문 및 기능을 모두 지원합니다(인수 목록은 한 번만 지정되므로 패턴 매칭에 다중 정의를 사용하는 것을 제외함).
지도 (\x -> x * x) [1..5] -- [1, 4, 9, 16, 25]를 반환합니다. 다음은 모두 동일합니다.
f x y = x + y f x = \y -> x + y f = \x y -> x + y Haxe
Haxe에서는 익명 함수를 lambda라고 하며 다음과 같은 구문을 사용합니다.function(argument-list) expression;.
변화하다 f = 기능.(x) 돌아가다 x*x; f(8); // 64 (기능.(x,y) 돌아가다 x+y)(5,6); // 11 자바
Java는 Lambda Expressions라는 이름의 익명 함수를 JDK [57]8부터 지원합니다.
람다 표현식은 쉼표로 구분된 형식 파라미터 목록인 화살표 토큰( )으로 구성됩니다.->)와 본문입니다.파라미터의 데이터형은 항상 생략할 수 있습니다.파라미터가 1개뿐인 경우 괄호도 생략할 수 있습니다.본문은 하나의 문 또는 문 [58]블록으로 구성될 수 있습니다.
// 파라미터 없음 () -> 시스템..나가..인쇄("안녕, 세상아") // 1개의 파라미터(이 예에서는 아이덴티티 함수). a -> a // 하나의 식으로 (a, b) -> a + b // 명시적 유형 정보 포함 (긴 아이디, 스트링 이름.) -> "id: " + 아이디 + ", 이름: " + 이름. // 코드 블록 포함 (a, b) -> { 돌아가다 a + b; } // 람다 본문에 여러 문이 있습니다.암호 차단이 필요해요 // 이 예에는 두 개의 중첩 람다 식도 포함되어 있습니다(첫 번째 식도 폐쇄입니다). (아이디, default 가격) -> { 선택적.< >제품.> 제품. = 제품 리스트.개울.().필터(p -> p.getId() == 아이디).우선 검색(); 돌아가다 제품..지도(p -> p.가격 설정()).오르세(default 가격); } 람다 표현식은 다음 예시와 같이 "기능 인터페이스"로 변환됩니다(하나 이상의 기본값 [58]또는 정적 메서드에 더해 추상 메서드가1개만 포함된 인터페이스로 정의됩니다.
일반의 학급 계산기. { 인터페이스 정수 연산 { 인트 작동(인트 a, 인트 b); 체납 정수 연산 바꾸다() { 돌아가다 (a, b) -> 작동(b, a); } } 사적인 정적인 인트 적용합니다.(인트 a, 인트 b, 정수 연산 동작) { 돌아가다 동작.작동(a, b); } 일반의 정적인 무효 주된(스트링... args) { 정수 연산 추가 = (a, b) -> a + b; 정수 연산 뺄셈 = (a, b) -> a - b; 시스템..나가..인쇄("40 + 2 = " + 적용합니다.(40, 2, 추가)); 시스템..나가..인쇄("20 - 10 = " + 적용합니다.(20, 10, 뺄셈)); 시스템..나가..인쇄("10 - 20 = " + 적용합니다.(20, 10, 뺄셈.바꾸다())); } } 이 예에서는, 라고 하는 이름의 기능 인터페이스를 사용하고 있습니다.IntegerMath선언됩니다.구현되는 람다 표현식IntegerMath에 전달됩니다.apply()실행할 메서드입니다.다음과 같은 기본 방식swap함수에 대한 방법을 정의합니다.
Java 8은 메서드 레퍼런스라는 이름의 다른 메커니즘을 도입했습니다.::연산자) 기존 방법에 람다를 생성합니다.함수 인터페이스의 추상 메서드에서 추출되었기 때문에 메서드 참조는 인수 수나 유형을 나타내지 않습니다.
IntBinary Operator 합 = 정수::합; 위의 예에서 기능하는 인터페이스는IntBinaryOperator추상적인 방법을 선언하다int applyAsInt(int, int)컴파일러가 메서드를 찾습니다.int sum(int, int)수업 중에java.lang.Integer.
자바 제한
Java 8 람다에는 다음과 같은 제한이 있습니다.
- Lamdas는 선택된 예외를 슬로우할 수 있지만 이러한 lamdas는 Collection API에서 사용되는 인터페이스에서는 작동하지 않습니다.
- 람다가 선언된 범위 내 변수는 사실상 최종 변수인 경우, 즉 람다 범위 내부 또는 외부에서 변환되지 않은 경우에만 람다 내부에 액세스할 수 있습니다.
자바스크립트
JavaScript/ECMAScript는 익명 함수를 지원합니다.
경계.((기능.(x){ 돌아가다 x * x; })(10)); ES6는 => 기호가 익명 함수의 매개 변수 목록을 본문과 구분하는 "기능" 구문을 지원합니다.
경계.((x => x * x)(10)); 이 구성은 북마크릿에서 자주 사용됩니다.예를 들어, 현재 문서의 제목(창 제목 표시줄에 표시됨)을 URL로 변경하려면 다음 북마크렛이 작동하는 것처럼 보일 수 있습니다.
자바스크립트:문서.직함=위치.href; 그러나 할당문이 값(URL 자체)을 반환하기 때문에 실제로 많은 브라우저가 이 값을 표시하는 새 페이지를 만듭니다.
대신 값을 반환하지 않는 어나니머스 함수를 사용할 수 있습니다.
자바스크립트:(기능.(){문서.직함=위치.href;})(); 첫 번째(외부) 괄호 쌍의 함수문은 어나니머스 함수를 선언합니다.이 함수는 마지막 괄호 쌍과 함께 사용할 때 실행됩니다.이 값은 다음과 거의 동일합니다.이러한 값은 환경에 다음과 같이 채웁니다.f익명의 기능과는 다르게요.
자바스크립트:변화하다 f = 기능.(){문서.직함=위치.href;}; f(); 임의의 어나니머스 함수의 새 페이지를 피하려면 void()를 사용합니다.
자바스크립트:무효(기능.(){돌아가다 문서.직함=위치.href;}()); 또는 그냥:
자바스크립트:무효(문서.직함=위치.href); JavaScript는 어나니머스 함수의 정의, 호출 및 평가의 의미에 대한 구문 하위 항목을 가지고 있습니다.이러한 잠재의식적 뉘앙스는 상위 가상 표현 평가의 직접적인 결과이다.즉시 호출된 함수 표현이라고 불리는 다음 구성 요소가 이를 나타냅니다.
(기능.(){ ... }()) 그리고.
(기능.(){ ... })() 「」를 나타내다.function(){ ... }"에 의해f구성체의 형식은 상위 가설 내의 상위 가설입니다.(f())그리고 상위 가설에 적용되는 상위 가설은(f)().
상위 표현의 일반적인 구문적 모호성, 함수에 괄호로 묶인 인수 및 함수 정의의 형식 매개 변수 주위에 괄호를 표시합니다.특히 JavaScript는 다음을 정의합니다.,(7) 상위 표현식의 맥락에서의 연산자.구문 형식이 식과 함수의 인수(함수 형식 매개 변수 구문 무시)에 일치하는 것은 단순한 우연이 아닙니다!한다면f위의 구성에서는 식별되지 않으며, 다음과 같이 됩니다.(())그리고.()()첫 번째는 상주 함수의 구문적 힌트를 제공하지 않지만 두 번째는 첫 번째 상위 가상 함수가 합법적인 JavaScript가 될 함수로 평가해야 합니다.(외부: 예를 들어,()는 식이 함수에 대해 평가되는 한 ([, {, 42, 42, function", {})이 될 수 있습니다.
또한 함수는 객체인스턴스(같은 오브젝트는 함수인스턴스)와 객체 리터럴 표기 괄호입니다.{}브레이싱된 코드의 경우 함수를 정의할 때 사용됩니다(사용하는 것과 반대).new Function(...)(특히 글로벌바인딩이 손상되었기 때문에) 매우 광범위한 비강성적인 의미에서 브라싱된 JavaScript 스테이트먼트의 임의의 시퀀스입니다.{stuff}는, 다음의 고정점이라고 생각할 수 있습니다.
(기능.(){( 기능.(){( ... {( 기능.(){물건}() )} ... )}() )}() ) 더 정확하지만 주의사항이 있다면
( 기능.(){물건}() ) ~= A_Fixed_Point_of( 기능.(){ 돌아가다 기능.(){ 돌아가다 ... { 돌아가다 기능.(){물건}() } ... }() }() ) 다음에 이어지는 JavaScript fragment의 어나니머스 함수의 의미에 주의해 주십시오.
function(){ ... }()에워싸지 않고()는 일반적으로 합법적이지 않습니다.(f=function(){ ... })"실패"하지 않음f와는 달리(function f(){ ... })
줄리아.
Julia에서 익명 함수는 구문을 사용하여 정의됩니다.(arguments)->(expression),
줄리아> f = x -> x*x; f(8) 64 줄리아> ((x,y)->x+y)(5,6) 11 리스프
Lisp 및 Scheme는 람다 미적분에 대한 참조인 "lambda" 구성을 사용하여 익명 함수를 지원합니다.Clojure는 "fn" 특수 형식과 #() 리더 구문을 사용하여 익명 함수를 지원합니다.
(람다 (arg) (* arg arg)) 일반적인 리스프
일반 리스프는 람다 표현이라는 개념을 가지고 있습니다.람다 표현식은 기호 "람다"를 첫 번째 요소로 하여 목록으로 작성됩니다.목록에는 인수 목록, 문서 또는 선언 및 함수 본문이 포함됩니다.람다 식은 람다 형태 내에서 특수 연산자 "함수"와 함께 사용할 수 있습니다.
(기능. (람다 (arg) (어떤 일을 하다 arg))) "function"은 #로 생략할 수 있습니다.또한 매크로 람다가 존재하여 함수 형태로 확장됩니다.
; 샤프 따옴표를 사용합니다. #'(람다 (arg) (어떤 일을 하다 arg)) ; 람다 매크로 사용: (람다 (arg) (어떤 일을 하다 arg)) Common Lisp에서 어나니머스 함수의 일반적인 용도는 맵카 등의 상위 함수에 전달하여 목록의 각 요소에 함수를 적용하고 결과 목록을 반환하는 것입니다.
(맵카 #'(람다 (x) (* x x)) '(1 2 3 4)) ; -> (1 4 9 16 ) Common Lisp의 lamda 형식을 사용하면 함수 호출에 람다 식을 쓸 수 있습니다.
((람다 (x y) (+ (sqrt x) (sqrt y))) 10.0 12.0) Common Lisp의 익명 함수는 나중에 글로벌 이름을 붙일 수도 있습니다.
(설정 (기호 함수 '카운터) (람다 (x) (* x x))) SQR이라는 이름을 사용하여 호출할 수 있습니다. (스쿠르 10.0) 스킴
Scheme의 명명된 함수는 이름에 결합된 익명의 함수에 대한 단순한 구문설탕입니다.
(정의하다(소미네임 arg) (어떤 일을 하다 arg)) 확장(및 동등)
(정의하다소미네임 (람다(arg) (어떤 일을 하다 arg))) 클로쥬르
Clojure는 "fn" 특수 형식을 통해 익명 기능을 지원합니다.
(fn [x] (+ x 3)) 람다를 정의하는 판독기 구문도 있습니다.
#(+ % %2%3) ; 3개의 인수를 사용하여 합계하는 어나니머스 함수를 정의합니다. Scheme와 마찬가지로 Clojure의 "이름 있는 기능"은 단순히 이름에 묶인 람다를 위한 통사적인 설탕입니다.
(정의하다 기능하다 [아쉬움] (+ 3 arg)) 확장 대상:
(방어하다 기능하다 (fn [아쉬움] (+ 3 arg))) 루아
Lua(Scheme와 거의 동일)에서는 모든 함수가 익명입니다.Lua에서 명명된 함수는 단순히 함수 [59]객체에 대한 참조를 유지하는 변수입니다.
그래서 루아에서는
기능. 후우(x) 돌아가다 2*x 끝. 통사당일 뿐이다
후우 = 기능.(x) 돌아가다 2*x 끝. 역순서 정렬에 익명 함수를 사용하는 예:
table.displaces(네트워크, 기능.(a,b) 돌아가다 a.이름. > b.이름. 끝.) 울프람어, 매스매티카
울프람 언어는 매스매티카의 프로그래밍 언어입니다.익명 함수는 후자의 프로그래밍에 중요합니다.여러 가지 방법으로 작성할 수 있습니다.다음은 숫자를 증가시키는 몇 가지 익명 함수입니다.첫 번째가 가장 일반적입니다. #1첫 번째 인수와&어나니머스 기능의 종료를 나타냅니다.
#1+1& 기능.[x,x+1] x \[기능.] x+1 예를 들어 다음과 같습니다.
f:= #1^2&;f[8] 64 #1+#2&[5,6] 11 또한 Mathematica에는 재귀적 익명 함수를 만들기 위한 추가 구성이 있습니다.기호 '#0'은 기능 전체를 나타냅니다.다음 함수는 입력의 계수를 계산합니다.
한다면[#1 == 1, 1, #1 * #0[#1-1]]& 예를 들어, 6개의 요인은 다음과 같습니다.
한다면[#1 == 1, 1, #1 * #0[#1-1]]&[6] 720 MATLAB, 옥타브
MATLAB 또는 Octab에서 익명 함수는 구문을 사용하여 정의됩니다.@(argument-list)expression인수 목록에 없는 변수는 모두 동봉된 범위에서 상속되며 값으로 캡처됩니다.
>> f = @(x)x*x; f(8) 응답하다 = 64 >> (@(x,y)x+y)(5,6) 옥타브에서만 동작하는 비율 응답하다 = 11 막시마
Maxima에서 익명 함수는 구문을 사용하여 정의됩니다.lambda(argument-list,expression),
f: 람다([x],x*x), f(8); 64 람다([x,y],x+y)(5,6); 11 ML
ML의 다양한 방언은 익명 기능을 지원합니다.
OCaml
OCaml의 어나니머스 함수는 선언된 이름이 없는 함수입니다.입력에 2를 곱한 어나니머스 함수의 예를 다음에 나타냅니다.
재밌어요 x -> x*2 이 예에서 fun은 함수가 어나니머스 함수임을 나타내는 키워드입니다.인수와 본문을 분리하기 위해 인수 x와 -[60]>를 전달합니다.
F#
F#은 다음과 같이 어나니머스 [17]기능을 지원합니다.
(재밌어요 x -> x * x) 20 // 400 표준 ML
표준 ML은 다음과 같이 익명 기능을 지원합니다.
fn arg => arg * arg
님
Nim은 여러 줄의 다중 표현식 익명 함수를 지원합니다.[33]
변화하다 이상 = 프로세서 (변수 1, 변수 2: 인트): 인트 = 변수 1 + 변수 2 주장하다 이상(1, 2) == 3 여러 줄의 예:
변화하다 이상 = 기능하다 (x: 인트): 부울 = 한다면 x > 0: 결과 = 진실의 또 다른: 결과 = 거짓의 주장하다 이상(9) 익명 함수는 다른 함수의 입력 매개 변수로 전달될 수 있습니다.
변화하다 도시들 = @[프랑크푸르트, '도쿄', '뉴욕'] 도시들.종류( 프로세서 (x, y: 스트링): 인트 = cmp(x.렌, y.렌) ) 어나니머스 함수는 기본적으로 이름이 없는 함수입니다.
펄
Perl 5
Perl 5는 다음과 같은 익명 [37]기능을 지원합니다.
(후보선수 { 인쇄물 "부름받았어\n" })->(); # 1. 완전히 익명으로 작성되었다고 한다. 나의 평방 달러 = 후보선수 { 나의 x달러 = 교대하다; x달러 * x달러 }; # 2. 변수에 할당 후보선수 카레시 { 나의 ($sub, @parambps) = @_; 돌아가다 후보선수 { $sub->(@parambps, @_) }; # 3. 다른 함수의 반환값으로서 } # Perl 프로그래밍에서의 커링 예시 후보선수 합 { 나의 합계 = 0; 합계 += $_ 위해서 @_; 합계 } # 인수 합계를 반환합니다. 나의 $쿠리 = 카레시 \&합, 5, 7, 9; 인쇄물 $쿠리->(1,2,3), "\n"; 인쇄수 27 (= 5 + 7 + 9 + 1 + 2 + 3 ) 다른 구성 요소에서는 베어 블록을 인수로 사용하여 한 파라미터의 람다 함수와 유사한 함수를 제공하지만 함수와 동일한 파라미터 전달 규칙을 가지고 있지 않습니다.@_는 설정되어 있지 않습니다.
나의 @parames(@parames) = 지도 { $_ * $_ } 1..10; # map 및 grep에서는 sub 키워드를 사용하지 않습니다. 나의 @square2 = 지도 $_ * $_, 1..10; # 하나의 식에 대해 필요 없는 중괄호 나의 @bad_module = 지도 { 인쇄물 위해서 @_ } 1..10; 일반 Perl 함수처럼 전달되지 않는 값 수 PHP
4.0.1 이전 버전에서는 PHP는 익명 [61]함수를 지원하지 않았습니다.
PHP 4.0.1에서 5.3까지
PHP 4.0.1은create_function최초의 익명 기능 지원이었습니다.이 함수 호출은 랜덤하게 명명된 새로운 함수를 만들고 해당 이름을 문자열로 반환합니다.
$foo = create_function(작성_함수)('$x', '$x*$x를 반환한다;'); $bar = create_function(작성_함수)("\$x", '반환'\$x*\$x;"); 메아리치다 $foo(10); 인수 목록과 함수 본문은 작은 따옴표로 묶거나 달러 기호를 이스케이프해야 합니다.그렇지 않으면 PHP는 "를 가정합니다.$x"는 변수를 의미합니다.$x「」를 남기지 않고, 문자열에 치환합니다(존재하지 않을 가능성이 있습니다).$x문자열에 ".따옴표가 있는 함수나 변수가 많은 함수의 경우, 의도한 함수 본문이 PHP가 해석하는 것인지 확인하는 것은 매우 귀찮을 수 있습니다.
의 각 호출create_function는 프로그램의 나머지 부분에 존재하며 프로그램 내의 메모리를 원래대로 사용하여 가비지를 수집할 수 없는 새로운 기능을 만듭니다.예를 들어 루프에서 익명 함수를 여러 번 생성하기 위해 이 기능을 사용하면 메모리 팽창과 같은 문제가 발생할 수 있습니다.
PHP 5.3
PHP 5.3은 다음과 같은 새 클래스를 추가했습니다.Closure마법의 방법__invoke()클래스 인스턴스를 호출할 [62]수 없게 됩니다.
x달러 = 3; 펑크 = 기능.(z달러) { 돌아가다 z달러 * 2; }; 메아리치다 펑크(x달러); // 인쇄 6 이 예에서는,$func의 예다.Closure그리고.echo $func($x)와 동등하다echo $func->__invoke($x). PHP 5.3은 익명 함수를 모방하지만 PHP 함수는 여전히 1등급 객체가 아니기 때문에 진정한 익명 함수를 지원하지 않습니다.
PHP 5.3은 폐쇄를 지원하지만 변수는 다음과 같이 명시되어야 합니다.
x달러 = 3; 펑크 = 기능.() 사용하다(&x달러) { x달러 *= 2; }; 펑크(); 메아리치다 x달러; // 인쇄 6 변수$x참조에 의해 구속되어 있기 때문에, 기동됩니다.$func는 그것을 수정하고 변경은 기능 외부에 표시됩니다.
PHP 7.4
화살표 기능은 PHP 7.4에서 도입되었습니다.
x달러 = 3; 펑크 = fn(z달러) => z달러 * 2; 메아리치다 펑크(x달러); // 인쇄 6 프롤로그의 방언
로그토크
Logtalk는 익명 술어(lambda 식)에 다음 구문을 사용합니다.
{FreeVar1, FreeVar2, ...}/[Lambda Parameter 1, Lambda Parameter 2, ...]> 목표빈 변수가 없고 목록 매핑 술어를 사용하는 간단한 예는 다음과 같습니다.
?- meta: map([X,Y]>(Y는 2*X), [1,2,3], Ys).Ys = [2,4,6] 예카레링도 가능합니다.위의 예는 다음과 같이 기술할 수 있습니다.
?- meta: map([X]>([Y]>>(Y는 2*X), [1, 2, 3], Ys.Ys = [2,4,6] 예비주얼 프롤로그
익명 함수(일반 익명 술어)는 Visual Prolog 버전 7.[63]2에서 도입되었습니다.익명 술어는 컨텍스트에서 값을 캡처할 수 있습니다.오브젝트 멤버로 작성된 경우 (캡처를 통해) 오브젝트 상태에 액세스할 수도 있습니다.This).
mkAdder인수를 캡처한 어나니머스 함수를 반환합니다.X마지막에는요.반환된 함수는 다음 함수를 추가하는 함수입니다.X그 논거에 대해서:
조항 추가(X) = { (Y) = X+Y }. 파이썬
Python은 lambda [39]형식을 통해 간단한 익명 함수를 지원합니다.lamda의 실행 가능한 본문은 표현식이어야 하며 문이 될 수 없습니다. 이는 효용을 제한하는 제한 사항입니다.람다가 반환하는 값은 포함된 식의 값입니다.람다 형태는 일반 기능이 가능한 모든 곳에서 사용할 수 있습니다.그러나 이러한 제한으로 인해 일반 기능의 매우 제한된 버전이 됩니다.다음은 예를 제시하겠습니다.
>>>후우 = 람다 x: x * x >>>후우(10) 100 일반적으로 Python 규약은 일반적으로 다른 언어에서 익명 함수를 사용하는 것과 동일한 범위에서 정의된 명명된 함수를 사용하는 것을 권장한다.이는 로컬로 정의된 함수가 폐쇄의 모든 힘을 구현하기 때문에 허용 가능하며 Python에서 람다를 사용하는 것만큼 효율적입니다.이 예에서는 내장된 전원 기능이 큐레이션되었다고 할 수 있습니다.
>>>방어하다 제조_pow(n): ... 방어하다 fixed_incent_pow(x): ... 돌아가다 전원(x, n) ... 돌아가다 fixed_incent_pow ... >>>스쿠르 = 제조_pow(2) >>>스쿠르(10) 100 >>>아기 = 제조_pow(3) >>>아기(10) 1000 R
R에서는 어나니머스 함수는 다음 구문을 사용하여 정의됩니다.function(argument-list)expression.
>f <-> 기능.(x)x*x; f(8) [1] 64 >(기능.(x,y)x+y)(5,6) [1] 11 라쿠
Raku에서는 모든 블록(if, while 등과 관련된 블록도)이 익명 함수입니다.r값으로 사용되지 않는 블록은 즉시 실행됩니다.
- 완전 익명, 작성 완료
{ "부름받았습니다"라고 말합니다.
- 변수에 할당되다
my $squarer1 = -> $x { $x * $x }; #2a. 포인트 블록 my $squarer2 = { $^x * $^x }; #2b. twigil my $squarer3 = { my $x = shift @_; $x * $x }; #2c. Perl 5 스타일
- 카레링
subadd ($m, $n) { $m + $n } my$7 = add(3, 4), my$add_one = &add.m = > 1); 내 $8 = $add_1,0007);
- What Code 객체
my $w = * - 1; # WhyCode 객체 my $b = { $_ - 1 }; # 기능은 동일하지만 콜 가능 블록
루비
Ruby는 block이라는 구문 구조를 사용하여 익명 기능을 지원합니다.Ruby의 블록에는 두 가지 데이터 유형이 있습니다. Procs는 폐쇄와 유사하게 동작하지만,lambdas는 어나니머스 [42]함수와 더 유사하게 동작합니다.메서드에 전달될 때 블록은 상황에 따라 Proc로 변환됩니다.
irb(메인):001:0># 예 1: irb(메인):002:0*# 블록을 사용한 순수 익명 함수. irb(메인):003:0*ex = [16.2, 24.1, 48.3, 32.4, 8.5] => [16.2, 24.1, 48.3, 32.4, 8.5] irb(메인):004:0>ex.정렬_by { x x - x.행선지 } # 정수 부분을 무시하고 소수 부분별로 정렬합니다. => [24.1, 16.2, 48.3, 32.4, 8.5] irb(메인):005:0># 예 2: irb(메인):006:0*# Proc의 명시적 객체로서의 퍼스트 클래스 함수 - irb(메인):007:0*ex = 프로세서.신규 { 놓다 "안녕, 세상아!" } => # <프로세서: 0x007ff4598705a0@(irb):7> irb(메인):008:0>ex.불러 안녕, 세상아! => 없음 irb(메인):009:0 ># 예 3: irb(메인):010:0*# 파라미터와 함께 람다 함수 객체를 반환하는 함수 irb(메인):011:0*방어하다 is_syslog_of(n) irb(메인):012:1> 람다{ x x % n == 0} irb(메인):013:1>끝. => 없음 irb(메인): 014:0>복수_4 = is_syslog_of(4) => # <프로세서: 0x007ff458b4588@(irb):12 (1300da)> irb(메인): 015:0>복수_4.불러(16) => 참 irb(메인):016:0>복수_4[15] => 거짓 녹
Rust에서는 [64]익명 함수를 클로저라고 합니다.다음 구문을 사용하여 정의합니다.
<파라미터명>: <type> -> <return-type> {<body>};예를 들어 다음과 같습니다.
f = x: i32 -> i32 { x * 2 };그러나 타입 추론을 통해 컴파일러는 각 파라미터의 타입과 리턴 타입을 추론할 수 있으므로 위의 폼은 다음과 같이 기술할 수 있습니다.
허락하다 f = x { x * 2 }; 단일 표현식의 폐쇄(즉, 줄이 한 개인 본체)의 경우, 곱슬곱슬한 괄호는 생략할 수 있다.
허락하다 f = x x * 2; 입력 매개 변수가 없는 폐쇄는 다음과 같이 작성됩니다.
허락하다 f = 프린트!("안녕, 세상아!"); 폐쇄는 기능 포인터를 예상하는 기능의 입력 파라미터로 전달될 수 있습니다.
// 함수 포인터를 인수로 사용하여 // 값 '5'로 호출하는 함수입니다. fn apply(f: fn(i32) -> i32 {// 암묵적인 반환 f(5) } fn main() {// 닫힘을 정의하여 f = x * 2; println({}, fln(/) 10/!";;;;;;;;;;;;;;;;;;;;;;;;;;;////////////////////////////////그러나 폐쇄 본체의 가치가 어떻게 포착되는지를 설명하기 위해서는 복잡한 규칙이 필요할 수 있다.이 명령어는 다음 명령어를 사용해 주세요.Fn,FnMut,그리고.FnOnce특징:[65]
Fn: 참조에 의한 폐쇄 캡처(&T참조 액세스만 있는 경우에도 호출할 수 있는 함수에 사용됩니다.&)를 도입합니다.FnMut: 가변 참조에 의한 폐쇄 캡처(&mut T는, 변경 가능한 참조 액세스(와 함께)가 있는 경우에 호출할 수 있는 함수에 사용됩니다.&mut)를 도입합니다.FnOnce: 값별 폐쇄 캡처(T한 번만 호출되는 함수에 사용됩니다.
이러한 특성으로 컴파일러는 가능한 [65]한 가장 제한적인 방법으로 변수를 캡처합니다.Rust는 평생 동안 값이 "차용"되고 예측 가능하고 명시적인 [66]방식으로 이동되도록 하기 때문에 값이 범위 간에 이동하는 방법을 제어하는 데 도움이 됩니다.
다음은 다음을 사용하여 입력 매개 변수로 폐쇄를 통과하는 방법을 보여 줍니다.Fn특성:
;고 값이 `5`. 2apply_by_ref<이 부르는 F타입(이것을 끓여다. 폐쇄적은`Fn` 특성 구현하는 제네릭 형식 예 정의된다)을 끓여의 가치로 하는 함수//.F>,(f:F)->, i32이 F:Fn(i32)->, i32{f(5)}fn main(){)){println!("나는:{값을 받}",));)두개 2f자};을 끓여인쇄하기 전에 그 함수를 적용합니다. 반환값 println!("5 * 2 = {}), apply_by_ref(f); } // ~ 프로그램 출력 ~~ // 값을 받았습니다: 5 // 5 * 2 = 10스칼라
Scala에서 익명 함수는 다음 [67]구문을 사용합니다.
(x: 내부, y: 내부) => x + y 예를 들어 익명함수가 다른 함수에 전달되는 파라미터일 때처럼 컴파일러는 익명함수의 파라미터 유형을 추론할 수 있으며 구문에서 생략할 수 있다.이러한 상황에서는 언더스코어 문자를 사용하여 이름 없는 파라미터를 도입하는 어나니머스 함수의 약어를 사용할 수도 있습니다.
값 목록. = 목록.(1, 2, 3, 4) 목록..왼쪽을 줄이다( (x, y) => x + y ) // 여기서 컴파일러는 x와 y의 유형이 모두 Int라고 추론할 수 있습니다. // 따라서 익명 함수의 파라미터에 대한 유형 주석이 필요하지 않습니다. 목록..왼쪽을 줄이다( _ + _ ) // 각 밑줄은 익명 함수의 새로운 이름 없는 매개 변수를 나타냅니다. // 그 결과 위의 익명 함수와 같은 값이 훨씬 짧아집니다. 스몰토크
Smalltalk에서는 익명 함수를 블록이라고 하며 "값" 메시지를 전송하여 호출(호출)합니다.여러 개의 인수를 전달할 경우 값 인수 수가 일치하는 "value:...value:" 메시지를 사용해야 합니다.
예를 들어 GNU Smalltalk에서는
st> f:= [:x x*x]f 값: 8 . 64 st > [ : x : y x + y ]값: 5 값: 6 . 11스몰톡 블록은 엄밀히 말하면 클로저로 정의되는 범위보다 오래 존속하면서도 선언된 변수를 참조할 수 있습니다.
st> f : = [ : a [ : n a + n ]값: 100 . BlockClosure "인수에 100 ("a"변수 내의 값)을 추가합니다."st> f값: 1 . 101 st> f값: 2 . 102 .재빠르다
스위프트에서는 익명 기능을 [46]클로저라고 부릅니다.구문의 형식은 다음과 같습니다.
{ (파라미터) -> 리턴 타입 에 진술 } 예를 들어 다음과 같습니다.
{ (s1: 스트링, s2: 스트링) -> 불 에 돌아가다 s1 > s2 } 다음과 같이 추론할 수 있는 경우 간결하고 표현하기 위해 파라미터 유형 및 반환 유형을 생략할 수 있습니다.
{ s1, s2 에 돌아가다 s1 > s2 } 마찬가지로 Swift는 단일 스테이트먼트 폐쇄에 대한 암묵적인 수익률 스테이트먼트도 지원합니다.
{ s1, s2 에 s1 > s2 } 마지막으로 파라미터 이름도 생략할 수 있습니다. 생략할 경우 파라미터는 $ 기호와 그 위치(예: $0, $1, $2 등)로 구성된 속기 인수 이름을 사용하여 참조됩니다.
{ $0 > $1 } TCL
Tcl에서 익명 제곱 함수를 2에 적용하는 방법은 다음과 같습니다.[68]
적용합니다. {x {expr} {x달러*x달러}}} 2 #는 4를 반환한다. 이 예에서는 Tcl에서 함수가 된다는 것이 무엇을 의미하는지 두 가지 후보가 나와 있습니다.가장 일반적인 것은 보통 명령어프리픽스라고 불리며 변수 f가 이러한 함수를 보유하고 있는 경우 함수 어플리케이션 f(x)를 실행하는 방법은 다음과 같습니다.
{*}f달러 x달러 어디에{*}는 확장 프리픽스입니다(Tcl 8.5의 새로운 기능).위의 예의 명령어프리픽스가 적용됩니다.{x {expr {$x*$x}}} 명령어 이름은 에 의해 명령어프리픽스에 바인드 할 수 있습니다.interp alias명령어를 입력합니다.명령어 프리픽스는 카레링을 지원합니다.명령어 프리픽스는 TCL API에서 매우 일반적입니다.
Tcl에서 "함수"의 다른 후보는 보통 람다라고 불리며 다음과 같이 나타납니다.{x {expr {$x*$x}}}위 예의 일부입니다.이 부분은 어나니머스 함수의 컴파일된 형식을 캐시하는 부분이지만 이 함수는 에 전달되어야만 호출할 수 있습니다.apply명령어를 입력합니다.람다는 카레를 지원하지 않습니다. 단, 한 쌍이 되지 않는 한apply명령어 프레픽스를 형성합니다.람다는 TCL API에서 희귀합니다.
바라
Vala에서는 익명 함수가 람다 [69]식으로 지원됩니다.
위임하다 인트 IntOp (인트 x, 인트 y); 무효 주된 () { IntOp 후우 = (x, y) => x * y; 설치하다.인쇄물(%d\n", 후우(10,5)); } Visual Basic.그물
Visual Basic.NET 2008은 람다 형식을 통해 익명 기능을 도입했습니다.암묵적 타이핑과 조합하여 VB는 익명 함수의 경제적인 구문을 제공합니다.Python과 마찬가지로 VB에도 있습니다.NET, 어나니머스 함수는 한 줄에 정의해야 합니다.복잡한 문장은 사용할 수 없습니다.또, VB의 어나니머스 기능.NET은 진정한 VB여야 합니다.그물Function- 값을 반환해야 합니다.
어둡다 후우 = 기능.(x) x * x 콘솔.기입선(후우(10)) Visual Basic.NET 2010에서는 반환값 없이 여러 줄의 람다 표현 및 익명 함수에 대한 지원이 추가되었습니다.예를 들어 스레드에서 사용하기 위한 함수입니다.
어둡다 t ~하듯이 신규 시스템..스레드화.실(후보선수 () 위해서 n ~하듯이 정수 = 0 로. 10 '10까지 카운트' 콘솔.기입선(n) '각 번호 인쇄' 다음 분. 끝. 후보선수 ) t.시작() 「 」를 참조해 주세요.
레퍼런스
- ^ "Higher order functions". learnyouahaskell.com. Retrieved 3 December 2014.
- ^ Fernandez, Maribel (2009), Models of Computation: An Introduction to Computability Theory, Undergraduate Topics in Computer Science, Springer Science & Business Media, p. 33, ISBN 9781848824348,
The Lambda calculus ... was introduced by Alonzo Church in the 1930s as a precise notation for a theory of anonymous functions
- ^ "Arrow function expressions - JavaScript". MDN.
- ^ "Bash lambda". GitHub. 2019-03-08.
- ^ BillWagner. "Lambda expressions - C# reference". docs.microsoft.com. Retrieved 2020-11-24.
- ^ "Closure support". Archived from the original on 2014-01-06. Retrieved 2014-01-05.
- ^ "Whats new in ColdFusion 10". Archived from the original on 2014-01-06. Retrieved 2014-01-05.
- ^ "Clojure - Higher Order Functions". clojure.org. Retrieved 2022-01-14.
- ^ "Managed COBOL Reference". Micro Focus Documentation. Micro Focus. Retrieved 25 February 2014.
- ^ "Functions - D Programming Language". dlang.org. Retrieved 2022-01-14.
- ^ a b "A tour of the Dart language". dart.dev. Retrieved 2020-11-24.
- ^ "Anonymous Methods in Delphi - RAD Studio". docwiki.embarcadero.com. Retrieved 2020-11-24.
- ^ "Functions — Dylan Programming". opendylan.org. Retrieved 2022-01-14.
- ^ "docs/syntax". elm-lang.org. Retrieved 2022-01-14.
- ^ a b "Erlang/Elixir Syntax: A Crash Course". elixir-lang.github.com. Retrieved 2020-11-24.
- ^ a b "Erlang -- Funs". erlang.org. Retrieved 2020-11-24.
- ^ a b cartermp. "Lambda Expressions: The fun Keyword - F#". docs.microsoft.com. Retrieved 2020-11-24.
- ^ "LAMBDA: The ultimate Excel worksheet function". microsoft.com. 25 January 2021. Retrieved 2021-03-30.
- ^ "Quotations - Factor Documentation". Retrieved 26 December 2015.
A quotation is an anonymous function (a value denoting a snippet of code) which can be used as a value and called using the Fundamental combinators.
- ^ "Frink". frinklang.org. Retrieved 2020-11-24.
- ^ a b "Anonymous Functions in GoLang". GoLang Docs. 9 January 2020. Retrieved 2020-11-24.
- ^ "Gosu Documentation" (PDF). Retrieved 4 March 2013.
- ^ "Groovy Documentation". Archived from the original on 22 May 2012. Retrieved 29 May 2012.
- ^ "Anonymous function - HaskellWiki". wiki.haskell.org. Retrieved 2022-01-14.
- ^ "Lambda". Haxe - The Cross-platform Toolkit. Retrieved 2022-01-14.
- ^ "Functions - JavaScript MDN". developer.mozilla.org. Retrieved 2022-01-14.
- ^ "Functions · The Julia Language". docs.julialang.org. Retrieved 2020-11-24.
- ^ "Higher-Order Functions and Lambdas - Kotlin Programming Language". Kotlin. Retrieved 2020-11-24.
- ^ "Programming in Lua : 6". www.lua.org. Retrieved 2020-11-24.
- ^ "Maple Programming: 1.6: Anonymous functions and expressions - Application Center". www.maplesoft.com. Retrieved 2020-11-24.
- ^ "Anonymous Functions - MATLAB & Simulink". www.mathworks.com. Retrieved 2022-01-14.
- ^ "Maxima 5.17.1 Manual: 39. Function Definition". maths.cnam.fr. Retrieved 2020-11-24.
- ^ a b "Nim Manual". nim-lang.github.io.
- ^ "Code Examples – OCaml". ocaml.org. Retrieved 2020-11-24.
- ^ "GNU Octave: Anonymous Functions". octave.org. Retrieved 2020-11-24.
- ^ "Function Literals". OpenSCAD User Manual. Wikibooks. Retrieved 22 February 2021.
- ^ a b "perlsub - Perl subroutines - Perldoc Browser". perldoc.perl.org. Retrieved 2020-11-24.
- ^ "PHP: Anonymous functions - Manual". www.php.net. Retrieved 2020-11-24.
- ^ a b "6. Expressions — Python 3.9.0 documentation". docs.python.org. Retrieved 2020-11-24.
- ^ "4.4 Functions: lambda". docs.racket-lang.org. Retrieved 2020-11-24.
- ^ "Functions". docs.raku.org. Retrieved 2022-01-14.
- ^ a b Sosinski, Robert (2008-12-21). "Understanding Ruby Blocks, Procs and Lambdas". Reactive.IO. Archived from the original on 2014-05-31. Retrieved 2014-05-30.
- ^ "Closures: Anonymous Functions that Can Capture Their Environment - The Rust Programming Language". doc.rust-lang.org. Retrieved 2022-01-14.
- ^ "Anonymous Functions". Scala Documentation. Retrieved 2022-01-14.
- ^ "Recitation 3: Higher order functions". www.cs.cornell.edu. Retrieved 2022-01-14.
- ^ a b "Closures — The Swift Programming Language (Swift 5.5)". docs.swift.org.
- ^ "Documentation - Everyday Types". www.typescriptlang.org. Retrieved 2022-01-14.
- ^ a b "Projects/Vala/Tutorial - GNOME Wiki!". wiki.gnome.org. Retrieved 2020-11-24.
- ^ KathleenDollard. "Lambda Expressions - Visual Basic". docs.microsoft.com. Retrieved 2022-01-14.
- ^ "Language Reference/Terms/Anonymous Predicates - wiki.visual-prolog.com". wiki.visual-prolog.com. Retrieved 2022-01-14.
- ^ "Pure Anonymous Function: Elementary Introduction to the Wolfram Language". www.wolfram.com. Retrieved 2022-01-14.
- ^ "Statement Exprs (Using the GNU Compiler Collection (GCC))". gcc.gnu.org. Retrieved 2022-01-12.
- ^ "Language Specification for Blocks — Clang 13 documentation". clang.llvm.org. Retrieved 2022-01-14.
- ^ "Lambda expressions (since C++11) - cppreference.com". en.cppreference.com. Retrieved 2022-01-14.
- ^ Järvi, Jaakko; Powell, Gary (n.d.). "Chapter 16. Boost.Lambda". Boost Documentation. Boost. Retrieved December 22, 2014.
- ^ "C# Language Specification 5.0". Microsoft Download Center.
- ^ "What's New in JDK 8".
- ^ a b Java 튜토리얼: Lambda Expressions, docs.oracle.com
- ^ "Programming in Lua - More about Functions". Archived from the original on 14 May 2008. Retrieved 2008-04-25.
- ^ "2.7. Anonymous Functions · GitBook". www.cs.cornell.edu.
- ^ http://php.net/create_function 페이지 맨 위에 "(PHP 4 > = 4.0.1, PHP 5)"로 표시됩니다.
- ^ "PHP: rfc:closures". wiki.php.net.
- ^ "Anonymous Predicates". Visual Prolog 언어 참조
- ^ "Closures - Rust By Example". doc.rust-lang.org.
- ^ a b "As input parameters - Rust By Example". doc.rust-lang.org.
- ^ "Lifetimes - Rust By Example". doc.rust-lang.org.
- ^ "Anonymous Function Syntax - Scala Documentation". Archived from the original on 2013-07-23. Retrieved 2010-12-31.
- ^ 적용 매뉴얼 페이지, 2012-09-06을 취득했습니다.
- ^ 발라 참조 매뉴얼, 2021-06-09를 검색했습니다.
외부 링크
- Anonymous Methods - 언제 사용해야 합니까? (Delphi의 익명 기능에 대한 블로그)
- 람다 식 컴파일: Scala vs.자바 8
- php 익명 함수 php 익명 함수
- 다양한 프로그래밍 언어로 기능하는 람다
