[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
@deffn
명령과 그 외의 정의 명령어로 함수, 변수, 매크로,
명령어, 옵션, 특수형태, 그리고 그 외의 artifact를 일관된 형태로 나타낼
수 있다.
Info 파일에서, 정의는 entity category--`함수', `변수', 혹은 무엇이든
간에--그 정의의 첫번째 줄에 나타나고, 그 다음에 그 entity의 이름과
인자가 온다. 인쇄된 매뉴얼의 경우, 이 명령어는 TeX이 그 entity의
이름과 그 인자를 왼쪽 공백에 출력하고, 그 category를 오른쪽 margin에
출력하도록 한다. 두개의 출력 형식 모두에서, 정의의 body는 들여쓰기
된다. 또, entity의 이름은 적당한 색인에 들어가게 된다: @deffn
은
그 이름을 함수 색인에 넣고, @defvr
은 변수 색인에 넣는 것 등과
같이 한다.
한개의 매뉴얼에서 한개의 주어진 이름에 대해 한개 이상의 정의가 있을
필요도 없고, 있어서도 안 된다. 요약이 들어 있는 부록은 명령어
정의보다는 @table
을 사용해야 한다.
15.1 The Template for a Definition | How to structure a description using a definition command. | |
15.2 Optional and Repeated Arguments | How to handle optional and repeated arguments. | |
15.3 Two or More `First' Lines | How to group two or more `first' lines. | |
15.4 The Definition Commands | All the definition commands. | |
15.5 Conventions for Writing Definitions | Conventions for writing definitions. | |
15.6 A Sample Function Definition |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
@deffn
명령은 함수와 같은 entity를 정의하는 데 쓴다.
@deffn
명령으로 정의를 하려면, @deffn
명령을 줄이 시작할
때 쓰고, 같은 줄에 그 entity의 category, 그 entity 자체의 이름, 그리고
(있다면) 그 인자를 쓴다. 그 다음에 계속되는 줄에 정의의 body를 쓴다.
(그 body에 예제를 포함시킬 수도 있다.) 끝으로, @end deffn
명령을 한줄에 단독으로 써서 정의를 끝낸다. (그 외의 정의 명령도 같은
형식으로 쓴다.)
정의의 template은 다음과 같다:
@deffn category name arguments… body-of-definition @end deffn |
예를 들어,
@deffn Command forward-word count This command moves point forward @var{count} words (or backward if @var{count} is negative). … @end deffn |
은 다음을 만든다.
- Command: forward-word count
This function moves point forward count words (or backward if count is negative). …
category의 이름을 title처럼 대문자로 시작하게 한다. `Interactive Command'처럼 category 이름에 공백이 들어가면, 그 주위에 중괄호를 쓴다. 예를 들어:
@deffn {Interactive Command} isearch-forward … @end deffn |
그렇지 않으면 두번째 단어가 그 entity의 이름으로 잘못 받아들여질 것이다.
몇몇 정의 명령은 다른 것들보다 더 일반적이다. 예를 들어, @deffn
명령은 함수와 같은 것들--인자를 받아들이는 entity--에 쓰이는 일반적인
명령어이다. 이 명령을 쓸 때, 그 entity가 속해 있는 category를 지정한다.
@deffn
명령은 세개의 변형된 명령이 미리 정의되어 있다. 그것은
@defun
, @defmac
, 그리고 @defspec
으로, 이
명령어들은 category를 알아서 지정해 준다: 각각 "함수", "매크로",
그리고 "Special Form"이다. (Lisp에서, special form은 함수와 매우
비슷한 entity이다.) @defvr
명령도 특정 종류의 변수를 쓰기 위해
몇개의 변형이 미리 지정되어 있다.
@defun
처럼, specialized 정의에 쓰이는 template은 category를
지정할 필요가 없다는 것을 빼면 일반적인 정의에 쓰이는 template과
같다.
@defun name arguments… body-of-definition @end defun |
즉,
@defun buffer-end flag This function returns @code{(point-min)} if @var{flag} is less than 1, @code{(point-max)} otherwise. … @end defun |
은 다음을 만든다.
- Function: buffer-end flag
This function returns
(point-min)
if flag is less than 1,(point-max)
otherwise. …
정의 내에 @example
을 사용하는 등, 함수 정의의 더 자세한 예를
보려면, See section A Sample Function Definition.
그 외의 specialized 명령은 @defun
처럼 동작한다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
어떤 entity는 선택 가능하거나, 반복되는 인자를 받아들이는데, 이 인자는 square bracket과 말줄임표같은 기호로 구분해서 지정할 수 있다. 예를 들어, special form은 보통 함수보다 더 복잡한 방법으로, 그 인자 리스트를 여러개의 인자로 나눈다.
다음은 가상의 special form의 예로 @defspec
명령이 들어 있는
줄이다.
- Special Form: foobar (var [from to [inc]]) body…
이 예에서, 인자 from과 to는 선택 가능하지만, 두개다 있거나, 두개 다 없거나 해야 한다. 인자가 있으면, inc도 선택 가능하다. 이 인자들은 var 인자와 함께 리스트 안에 들어 있어서, 이 form의 나머지 element가 모두 들어 있는 body와 구분한다.
Texinfo 소스 파일에서, @defspec
줄은 다음과 같이 쓴다 (다음
예에서처럼, 두 줄에 걸쳐 나눠지지 않는다).
@defspec foobar (@var{var} [@var{from} @var{to} [@var{inc}]]) @var{body}@dots{} |
이 함수는 `foobar'로 `함수와 변수 색인'에 열거되어 있다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
정의에서 두개 이상의 `첫번째' 혹은 머릿줄을 쓰려면, 첫번째
@deffn
줄 다음에 @deffnx
로 시작하는 줄을 쓴다.
@deffnx
명령은 앞줄과의 사이에 수직으로 공백을 넣지 않는 다는
것을 제외하면 @deffn
와 완전히 똑같이 동작한다.
예를 들어,
@deffn {Interactive Command} isearch-forward @deffnx {Interactive Command} isearch-backward These two search commands are similar except … @end deffn |
는 다음을 만든다.
These two search commands are similar except …
그 외의 정의 명령도 각각 `x' 형태가 있다: @defunx
,
@defvrx
, @deftypefunx
등.
`x' 형태는 @itemx
와 비슷하다; @itemx
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Texinfo는 수십개의 정의 명령을 제공하고, 이 명령어를 모두 이 절에서 설명한다.
정의 명령은 자동으로 그 entity의 이름을 적당한 색인에 넣는다: 예를 들어,
@deffn
, @defun
, 그리고 @defmac
은 함수 이름을
함수 색인에 넣는다; @defvr
과 @defvar
은 변수 이름을 변수
색인에 넣는다.
다음에 나올 예들은 대부분 Lisp의 예이지만, 이 명령들은 다른 프로그래밍 언어에도 사용될 수 있다.
15.4.1 Functions and Similar Entities | Commands for functions and similar entities. | |
15.4.2 Variables and Similar Entities | Commands for variables and similar entities. | |
15.4.3 Functions in Typed Languages | Commands for functions in typed languages. | |
15.4.4 Variables in Typed Languages | Commands for variables in typed languages. | |
15.4.5 Object-Oriented Programming | Commands for object-oriented programming. | |
15.4.6 Data Types | The definition command for data types. |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
이 절은 함수, 그리고 함수와 비슷한 entity들을 정의하는 명령어들을 설명한다:
@deffn category name arguments…
@deffn
명령은 함수, interactive commands, 그리고 그 외에 인자를
받아들이는 비슷한 entity들을 일반적으로 정의하는 명령이다.
정의하는 entity의 category를 나타내는 용어는 직접 결정해야 한다; 예를
들어, "함수"는 그 entity가 함수일때 쓸 수 있을 것이다. @deffn
명령은 줄이 시작할 때 쓰고, 같은 줄에 계속 entity의 catogory, 이
entity의 이름, 그리고 인수가 있다면 그 인수를 쓴다. 이 정의는
@end deffn
명령을 한줄에 단독으로 써서 끝낸다.
예를 들어, 다음에 정의가 있다.
@deffn Command forward-char nchars Move point forward @var{nchars} characters. @end deffn |
이 예는 nchars라는 한개의 인자를 가진 forward-char
라는
이름의 "명령어"를 간단히 정의했다.
@deffn
은 nchars와 같은 인자의 이름을 @var
가 사용된
경우와 같이 이탤릭체 혹은 대문자로 표시한다. 왜냐하면, 우리는 이 이름을
metasyntactic 변수로 생각하기 때문이다--이 인자들은 실제 인자의 값을
나타낸다. 여기 설명하는 텍스트 내에서, 이 인자의 값을 참조하려면
@var
를 분명히 써서 인자 이름을 쓴다. 위의 예에서, 이런 방법으로
`@var{nchars}'를 썼다.
@deffn
의 template은:
@deffn category name arguments… body-of-definition @end deffn |
@defun name arguments…
@defun
명령은 함수를 정의하는 명령어이다. @defun
은
`@deffn Function …'와 같다.
예를 들어,
@defun set symbol new-value Change the value of the symbol @var{symbol} to @var{new-value}. @end defun |
은 인자가 symbol과 new-value인 함수 set
을 간단히
설명한다. @defun
줄의 인자 이름은 마치 @var
안에 쓴
것처럼 자동으로 이탤릭체 혹은 대문자로 쓰여진다. 이 정의는 한줄에
단독으로 @end defun
을 써서 끝낸다.
template은:
@defun function-name arguments… body-of-definition @end defun |
@defun
은 함수 색인에 항목을 만든다.
@defmac name arguments…
@defmac
명령은 매크로를 정의하는 명령어이다. @defmac
은
`deffn Macro …'와 동일하고, @defun
과 비슷하게
동작한다.
@defspec name arguments…
@defspec
명령은 special form에 대한 정의 명령어이다. (Lisp에서,
special form은 function과 매우 비슷한 entity이다. see (elisp)Special Forms section `Special Forms' in GNU Emacs Lisp Reference Manual.) @defspec
은
`@deffn {Special Form} …'와 동일하고, @defun
과
비슷하게 동작한다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
다음은 변수와 변수와 비슷한 entity를 정의하는 명령이다:
@defvr category name
@defvr
명령은 변수와 비슷한 무언가--어떤 값을 저장하고 있는
entity--를 일반적으로 정의하는 명령어이다. 정의될 entity의 category를
설명하는 용어를 지정해야 한다; 예를 들어, "Variable"은 그 entity가
변수일 때 쓸 수 있다. @defvr
명령을 줄이 시작할 때쓰고, 같은
줄에 그 entity의 category와 그 entity의 이름을 쓴다.
category 이름을 title처럼 대문자로 시작하게 한다. category 이름이 "User Option"처럼 공백문자를 포함하면, 중괄호로 둘러싼다. 그렇지 않으면 두번째 단어가 entity의 이름으로 잘못 들어갈 것이다. 예를 들어,
@defvr {User Option} fill-column This buffer-local variable specifies the maximum width of filled lines. … @end defvr |
이 정의는 @end defvr
을 한 줄에 단독으로 써서 끝낸다.
template은:
@defvr category name body-of-definition @end defvr |
@defvr
은 name에 대한 항목을 변수 색인에 만든다.
@defvar name
@defvar
명령어는 변수를 정의하는 명령어이다. @defvar
은
`@defvr Variable …'와 동일하다.
예를 들어:
@defvar kill-ring … @end defvar |
기본 틀은:
@defvar name body-of-definition @end defvar |
@defvar
은 name에 대한 항목을 변수 색인에 만든다.
@defopt name
@defopt
명령은 user options에 대해 정의하는 명령어이다.
user option은 사용자가 원하는 대로 바꿀 수 있는 변수이다; Emacs에는
그러한 것이 많다 (see (emacs)Variables section `Variables' in The GNU Emacs Manual). @defopt
는 `@defvr {User
Option} …'와 같고, @defvar
와 같이 동작한다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
@deftypefn
명령과 그의 변형은 C와 C++처럼 변수와 함수의 타입을
선언해야 하는 언어에서 함수를 설명하는 데 쓰인다.
@deftypefn category data-type name arguments…
@deftypefn
명령은 인자를 받아들이고, 타입이 있는 함수 및 그와
비슷한 entity를 정의하는 일반적인 명령어이다. @deftypefn
명령은
줄이 시작할 때 쓰고, 같은 줄에 설명할 entity의 category를 쓰고, return
값의 타입, 이 entity의 이름, 그리고 인자가 있다면 그 인자들을 쓴다.
예를 들어,
@deftypefn {Library Function} int foobar (int @var{foo}, float @var{bar}) … @end deftypefn |
("…" 앞의 텍스트에서, 위에서는 두줄로 나타났지만, 실제로는 Texinfo 파일에서는 한 줄이다) 이것은 Info에서 다음을 만든다:
-- Library Function: int foobar (int FOO, float BAR) … |
이 의미는 foobar
가 int
를 리턴하고, 그 인자가
foo(int
타입)과 bar(float
타입)인 "라이브러리
함수"라는 뜻이다.
@deftypefn
안에 쓰는 인자의 이름은 @var
가 자동으로 붙지
않는다--왜냐하면 @deftypefn
내의 실제 인자의 이름은 대부분
데이타 타입의 이름과, 키워드로 구분되기 때문이다. Texinfo는 자동으로
이걸 찾아내지 못한다. 그 대신에 인자의 이름 주위에 직접 @var
를
써야 한다. 위의 예에서, 인자의 이름은 `foo'와 `bar'이다.
@deftypefn
의 template은 다음과 같다:
@deftypefn category data-type name arguments … body-of-description @end deftypefn |
만약 category나 data type이 한 단어보다 많을때 한개의 인자로 만들려면 중괄호로 묶어야 한다.
Ada와 같은 package가 있는 언어 내의 프로시저를 설명하려 할때,
deftypefn
을 앞의 문단에서 설명한 원칙과는 좀 다른 모양으로 써도
된다.
예를 들어:
@deftypefn stacks private push (@var{s}:in out stack; @var{n}:in integer) … @end deftypefn |
(@deftypefn
의 인자는 세 줄에 나눠져서 보이지만, 실제 Texinfo
파일에서는 한 줄이어야 한다.)
이 예에서, 프로시저는 프로시저로 구분되지 않고 stacks
라는
패키지에 속한 것으로 분류되었고, 그 데이타 타입은 private
이다.
(프로시저의 이름은 push
이고, 그 인자는 s와 n이다.)
@deftypefn
은 name에 대한 항목을 함수 색인 안에 만든다.
@deftypefun data-type name arguments…
@deftypefun
명령은 타입이 있는 언어 내의 함수에 쓰이도록 특화된
정의 명령이다. 이 명령은 `@deftypefn Function …'와
동일하다.
즉,
@deftypefun int foobar (int @var{foo}, float @var{bar}) … @end deftypefun |
은 Info에서 다음과 같이 만든다:
-- Function: int foobar (int FOO, float BAR) … |
그 template은:
@deftypefun type name arguments… body-of-description @end deftypefun |
@deftypefun
은 name에 대한 항목을 함수 색인에 넣는다.
@deftypemethod class data-type method-name arguments…
@deftypemethod
명령은 C++이나 Java와 같은 object-oriented typed
language 내의 method에 대한 정의 명령이다. 이 명령은
@deftypefn
에 이 method를 포함하는 클래스를 정의하는 class
인자를 덧붙인 것과 비슷하다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
명령은 타입이 있는 언어 변수는 타입이 있는 함수와 비슷하게 처리된다.
See section Functions in Typed Languages. 일반적인 정의 명령인 @deftypevr
은
@deftypefn
과 대응되고, 특화된 정의 명령인 @deftypevar
은
@deftypefun
과 대응된다.
@deftypevr category data-type name
@deftypevr
명령은 타입이 있는 언어 내의 변수와 같은 것(어떤 값을
기록하는 entity)을 정의하는 명령이다. 정의할 entity의 category를
설명하는 말을 직접 결정해야 한다; 예를 들어, 그 entity가 변수일 때
"변수"가 사용될 수 있다.
@deftypevr
명령은 줄이 시작할 때 쓰고, 같은 줄에 설명할 entity의
category를 쓰고, 데이타 타입, 그리고 이 entity의 이름을 쓴다.
예를 들어:
@deftypevr {Global Flag} int enable … @end deftypevr |
은 Info에서 다음을 만든다:
-- Global Flag: int enable … |
template은:
@deftypevr category data-type name body-of-description @end deftypevr |
@deftypevr
은 name에 대한 항목을 변수 색인에 넣는다.
@deftypevar data-type name
@deftypevar
명령은 타입이 있는 언어에서 변수를 선언하는 데 쓰는
특화된 정의 명령이다. @deftypevar
은 `@deftypevr Variable
…'와 같다.
예를 들어:
@deftypevar int fubar … @end deftypevar |
은 Info에서 다음을 만든다:
-- Variable: int fubar … |
template은 다음과 같다:
@deftypevar data-type name body-of-description @end deftypevar |
@deftypevar
은 name에 대한 항목을 변수 색인에 넣는다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
다음은 object-oriented programming에 사용되는 abstract object 설명을 포맷팅하는 명령이다. 클래스는 abstract object를 정의하는 타입이다. 클래스의 instance는 그 클래스의 타입을 가진 특정한 object이다. instance variable은 이 클래스에 속하는 변수이면서 각각의 instance는 각각의 값을 가진다.
정의 내에서 클래스의 이름이 어떤 프로그래밍 시스템 내에서 어떤 클래스를
정의하는 이름이라면, 그 주위에 @code
를 써야 한다. 그렇지 않으면
클래스 이름은 보통 텍스트 폰트로 인쇄된다.
@defcv category class name
@defcv
명령은 object-oriented programming에서 클래스에 속한
변수를 정의하는 일반적인 정의 명려이다. @defcv
명령 다음에는
세개의 인자가 온다; 정의할 변수의 category, 속해 있는 클래스, 그리고 그
이름이다. 즉,
@defcv {Class Option} Window border-pattern … @end defcv |
위의 예는 Window
클래스의 border-pattern
클래스
옵션을 정의할 때 그 첫번째 줄을 어떻게 쓸지 보여준다.
template은
@defcv category class name … @end defcv |
@defcv
는 변수 색인에 항목을 만든다.
@defivar class name
@defivar
명령은 object-oriented programming 내의 instance
변수를 정의하는 명령이다. @defivar
는 `@defcv {Instance
Variable} …'와 동일하다.
template은:
@defivar class instance-variable-name body-of-definition @end defivar |
@defivar
는 변수 색인에 항목을 하나 만든다.
@defop category class name arguments…
@defop
명령은 object-oriented programming에서 method와 같은
entity를 정의하는 데 쓰는 일반적인 명령이다. 이 entity는 함수와 같이
인자를 받지만, 이 enity는 특정 클래스와 연관되어 있다.
예를 들어, wrapper라고 부르는 시스템이 있다. 이 시스템은 method와
마찬가지로 클래스와 연관되어 있지만, 함수라기 보다는 매크로처름
동작한다. wrapper를 정의할 때 @defop Wrapper
라고 쓸 수 있다.
어떤 경우에는 method와 operation을 구분하는 것이 좋다. 어떤
operation은 어떤 method에 대한 specification이라고 생각할 수 있다. 즉,
어떤 윈도우 시스템은 모든 윈도우 클래스에 expose
라는 이름의
method를 만들 수 있다; 우리는 일반적으로 이 윈도우 시스템이 expose
operation을 정의 했다고 말할 수 있다. 보통, operation은 이름을 갖고
있고, 인자의 패턴을 지정하기도 한다; 이 operation을 implement하는 모든
method는 같은 인자를 받는다, 왜냐하면 이 operation을 사용하는
application은 어떤 method가 이 operation을 implement할 지 알지 않고도 이
operation을 사용할 수 있기 때문이다.
보통 method보다는 operation을 문서화 하는 것이 더 알기 쉽다. 예를 들어,
윈도우 application 개발자는 expose
operation에 대해서 알아야
하지만, 주어진 윈도우의 클래스가 이 operation을 implement하는 method를
갖고 있는지 신경쓸 필요가 없다. 이 operation을 정의하려면, 다음과 같이
쓸 것이다:
@defop Operation windows expose |
@defop
명령은 줄이 시작할 때 쓰고, 같은 줄에 operation의
category 이름, 이 operation의 클래스 이름, 이 operation의 이름, 그리고
그 인자가 있다면 인자들을 쓴다.
template은:
@defop category class name arguments… body-of-definition @end defop |
@defop
creates an entry, such as `expose
on
windows
', in the index of functions.
@defmethod class name arguments…
@defmethodd
명령은 object-oriented programming에서 method를
정의하는 명령이다. method는 일종의 함수로 특정한 object의 클래스와 그
서브클래스에 대한 operation을 implement한다. Lisp machine에서, method는
실제로 함수이지만, 보통 defmethod
로 정의된다.
@defmethod
는 `@defop Method …'와 같다. 이 명령은
줄이 시작할 때 쓰고, 그 다음에 그 method의 클래스의 이름, 그 method의
이름, 그리고 인자가 있다면 인자들를 쓴다.
예를 들어,
@defmethod |
위의 예는 bar-class
클래스의 bar-method
라는 method를
정의한다. 이 method는 한개의 인자를 받는다.
template은:
@defmethod class method-name arguments… body-of-definition @end defmethod |
@defmethod
는 `bar-method
on bar-class
와 같은
항목을 함수 색인에 만든다.
@deftypemethod class data-type name arguments…
@deftypemethod
명령은 C++이나 Java와 같은 object-oriented typed
language에서 method를 정의하는 명령어이다. 이것은 @defmethod
명령에 data-type의 인자를 더해서 그 method의 return type을
지정한다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
다음은 data type에 대한 명령어이다:
@deftp category name attributes…
@deftp
명령은 data type을 정의하는 일반적인 명령어이다. 이
명령은 줄이 시작할 때 쓰고, 같은 줄에 category, 타입의 이름(int
나
float
와 같은 단어), 그리고 그 타입의 object의 attribute 이름들을
쓴다. 즉, int
나 float
를 기술하기 위해 이 명령을 사용할
수도 있고, 이 경우에 data type
을 category로 사용한다. (data
type은 어떤 object들의 category이고, 이 category는 이 object들에 대해
어떤 operation이 가능한지 결정하는 데 쓰인다.)
예를 들어, Lisp에서 pair는 특정 data type의 이름이고, 이 type의
object는 CAR와 CDR이라는 두개의 slot이 있다. 다음은 어떻게
pair
를 기술하는 첫번째 줄의 예이다.
@deftp {Data type} pair car cdr … @end deftp |
template은 다음과 같다:
@deftp category name-of-type attributes… body-of-definition @end deftp |
@deftp
는 data type 색인에 항목을 추가한다.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
@deffn
, @defun
, 또는 그 외의 정의 명령을 사용해서 정의를
쓸 때, 이 인자는 그 정의의 의미를 나타내는데, forward-word
기능에
count를 사용해서 주의해서 쓰기 바란다. 또, 어떤 인자가
integer와 같은 타입의 이름인 경우, 실제 그 인자가 그 type인지
주의하라.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
어떤 함수의 정의가 @defun
과 @end defun
명령을 사용한다.
이 함수의 이름은 @defun
명령 다음에 오고, 같은 줄에 계속해서
인수의 리스트가 온다.
다음은 see (elisp)Calling Functions section `Calling Functions' in The GNU Emacs Lisp Reference Manual에서 인용한 정의이다.
- Function: apply function &rest arguments
apply
calls function with arguments, just likefuncall
but with one difference: the last of arguments is a list of arguments to give to function, rather than a single argument. We also say that this list is appended to the other arguments.
apply
returns the result of calling function. As withfuncall
, function must either be a Lisp function or a primitive function; special forms and macros do not make sense inapply
.
(setq f 'list) ⇒ list (apply f 'x 'y 'z) error--> Wrong type argument: listp, z (apply '+ 1 2 '(3 4)) ⇒ 10 (apply '+ '(1 2 3 4)) ⇒ 10 (apply 'append '((a b c) nil (x y z) nil)) ⇒ (a b c x y z)An interesting example of using
apply
is found in the description ofmapcar
.
Texinfo 소스 파일에서, 이 예는 다음과 같이 보인다.
@defun apply function &rest arguments @code{apply} calls @var{function} with @var{arguments}, just like @code{funcall} but with one difference: the last of @var{arguments} is a list of arguments to give to @var{function}, rather than a single argument. We also say that this list is @dfn{appended} to the other arguments. @code{apply} returns the result of calling @var{function}. As with @code{funcall}, @var{function} must either be a Lisp function or a primitive function; special forms and macros do not make sense in @code{apply}. @example (setq f 'list) @result{} list (apply f 'x 'y 'z) @error{} Wrong type argument: listp, z (apply '+ 1 2 '(3 4)) @result{} 10 (apply '+ '(1 2 3 4)) @result{} 10 (apply 'append '((a b c) nil (x y z) nil)) @result{} (a b c x y z) @end example An interesting example of using @code{apply} is found in the description of @code{mapcar}.@refill @end defun |
이 매뉴얼에서, 이 함수는 apply
라는 이름으로 명령어와 변수 색인에
들어 있다.
일반적인 변수와 user option은 함수와 같은 형식을 사용해서 기술된다. 단 변수는 인자를 받지 않는다.
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Autobuild on March, 29 2007 using texi2html 1.76.