Mercurial > emacs
annotate lispref/symbols.texi @ 8580:648f78c8ecf5
Fixed bug in tcl-guess-application.
author | Tom Tromey <tromey@redhat.com> |
---|---|
date | Sun, 21 Aug 1994 20:33:05 +0000 |
parents | 2d4db32cccd5 |
children | 73dc8205d259 |
rev | line source |
---|---|
6411 | 1 @c -*-texinfo-*- |
2 @c This is part of the GNU Emacs Lisp Reference Manual. | |
3 @c Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. | |
4 @c See the file elisp.texi for copying conditions. | |
5 @setfilename ../info/symbols | |
6 @node Symbols, Evaluation, Sequences Arrays Vectors, Top | |
7 @chapter Symbols | |
8 @cindex symbol | |
9 | |
10 A @dfn{symbol} is an object with a unique name. This chapter | |
11 describes symbols, their components, their property lists, and how they | |
12 are created and interned. Separate chapters describe the use of symbols | |
13 as variables and as function names; see @ref{Variables}, and | |
14 @ref{Functions}. For the precise read syntax for symbols, see | |
15 @ref{Symbol Type}. | |
16 | |
17 You can test whether an arbitrary Lisp object is a symbol | |
18 with @code{symbolp}: | |
19 | |
20 @defun symbolp object | |
21 This function returns @code{t} if @var{object} is a symbol, @code{nil} | |
22 otherwise. | |
23 @end defun | |
24 | |
25 @menu | |
26 * Symbol Components:: Symbols have names, values, function definitions | |
27 and property lists. | |
28 * Definitions:: A definition says how a symbol will be used. | |
29 * Creating Symbols:: How symbols are kept unique. | |
30 * Property Lists:: Each symbol has a property list | |
31 for recording miscellaneous information. | |
32 @end menu | |
33 | |
34 @node Symbol Components, Definitions, Symbols, Symbols | |
35 @section Symbol Components | |
36 @cindex symbol components | |
37 | |
38 Each symbol has four components (or ``cells''), each of which | |
39 references another object: | |
40 | |
41 @table @asis | |
42 @item Print name | |
43 @cindex print name cell | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
44 The @dfn{print name cell} holds a string that names the symbol for |
6411 | 45 reading and printing. See @code{symbol-name} in @ref{Creating Symbols}. |
46 | |
47 @item Value | |
48 @cindex value cell | |
49 The @dfn{value cell} holds the current value of the symbol as a | |
50 variable. When a symbol is used as a form, the value of the form is the | |
51 contents of the symbol's value cell. See @code{symbol-value} in | |
52 @ref{Accessing Variables}. | |
53 | |
54 @item Function | |
55 @cindex function cell | |
56 The @dfn{function cell} holds the function definition of the symbol. | |
57 When a symbol is used as a function, its function definition is used in | |
58 its place. This cell is also used to make a symbol stand for a keymap | |
59 or a keyboard macro, for editor command execution. Because each symbol | |
60 has separate value and function cells, variables and function names do | |
61 not conflict. See @code{symbol-function} in @ref{Function Cells}. | |
62 | |
63 @item Property list | |
64 @cindex property list cell | |
65 The @dfn{property list cell} holds the property list of the symbol. See | |
66 @code{symbol-plist} in @ref{Property Lists}. | |
67 @end table | |
68 | |
69 The print name cell always holds a string, and cannot be changed. The | |
70 other three cells can be set individually to any specified Lisp object. | |
71 | |
72 The print name cell holds the string that is the name of the symbol. | |
73 Since symbols are represented textually by their names, it is important | |
74 not to have two symbols with the same name. The Lisp reader ensures | |
75 this: every time it reads a symbol, it looks for an existing symbol with | |
76 the specified name before it creates a new one. (In GNU Emacs Lisp, | |
77 this lookup uses a hashing algorithm and an obarray; see @ref{Creating | |
78 Symbols}.) | |
79 | |
80 In normal usage, the function cell usually contains a function or | |
81 macro, as that is what the Lisp interpreter expects to see there | |
82 (@pxref{Evaluation}). Keyboard macros (@pxref{Keyboard Macros}), | |
83 keymaps (@pxref{Keymaps}) and autoload objects (@pxref{Autoloading}) are | |
84 also sometimes stored in the function cell of symbols. We often refer | |
85 to ``the function @code{foo}'' when we really mean the function stored | |
86 in the function cell of the symbol @code{foo}. We make the distinction | |
87 only when necessary. | |
88 | |
89 The property list cell normally should hold a correctly formatted | |
90 property list (@pxref{Property Lists}), as a number of functions expect | |
91 to see a property list there. | |
92 | |
93 The function cell or the value cell may be @dfn{void}, which means | |
94 that the cell does not reference any object. (This is not the same | |
95 thing as holding the symbol @code{void}, nor the same as holding the | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
96 symbol @code{nil}.) Examining a cell that is void results in an error, |
6411 | 97 such as @samp{Symbol's value as variable is void}. |
98 | |
99 The four functions @code{symbol-name}, @code{symbol-value}, | |
100 @code{symbol-plist}, and @code{symbol-function} return the contents of | |
101 the four cells of a symbol. Here as an example we show the contents of | |
102 the four cells of the symbol @code{buffer-file-name}: | |
103 | |
104 @example | |
105 (symbol-name 'buffer-file-name) | |
106 @result{} "buffer-file-name" | |
107 (symbol-value 'buffer-file-name) | |
108 @result{} "/gnu/elisp/symbols.texi" | |
109 (symbol-plist 'buffer-file-name) | |
110 @result{} (variable-documentation 29529) | |
111 (symbol-function 'buffer-file-name) | |
112 @result{} #<subr buffer-file-name> | |
113 @end example | |
114 | |
115 @noindent | |
116 Because this symbol is the variable which holds the name of the file | |
117 being visited in the current buffer, the value cell contents we see are | |
118 the name of the source file of this chapter of the Emacs Lisp Manual. | |
119 The property list cell contains the list @code{(variable-documentation | |
120 29529)} which tells the documentation functions where to find the | |
121 documentation string for the variable @code{buffer-file-name} in the | |
122 @file{DOC} file. (29529 is the offset from the beginning of the | |
123 @file{DOC} file to where that documentation string begins.) The | |
124 function cell contains the function for returning the name of the file. | |
125 @code{buffer-file-name} names a primitive function, which has no read | |
126 syntax and prints in hash notation (@pxref{Primitive Function Type}). A | |
127 symbol naming a function written in Lisp would have a lambda expression | |
128 (or a byte-code object) in this cell. | |
129 | |
130 @node Definitions, Creating Symbols, Symbol Components, Symbols | |
131 @section Defining Symbols | |
132 @cindex definition of a symbol | |
133 | |
134 A @dfn{definition} in Lisp is a special form that announces your | |
135 intention to use a certain symbol in a particular way. In Emacs Lisp, | |
136 you can define a symbol as a variable, or define it as a function (or | |
137 macro), or both independently. | |
138 | |
139 A definition construct typically specifies a value or meaning for the | |
140 symbol for one kind of use, plus documentation for its meaning when used | |
141 in this way. Thus, when you define a symbol as a variable, you can | |
142 supply an initial value for the variable, plus documentation for the | |
143 variable. | |
144 | |
145 @code{defvar} and @code{defconst} are special forms that define a | |
146 symbol as a global variable. They are documented in detail in | |
147 @ref{Defining Variables}. | |
148 | |
149 @code{defun} defines a symbol as a function, creating a lambda | |
150 expression and storing it in the function cell of the symbol. This | |
151 lambda expression thus becomes the function definition of the symbol. | |
152 (The term ``function definition'', meaning the contents of the function | |
153 cell, is derived from the idea that @code{defun} gives the symbol its | |
154 definition as a function.) @xref{Functions}. | |
155 | |
156 @code{defmacro} defines a symbol as a macro. It creates a macro | |
157 object and stores it in the function cell of the symbol. Note that a | |
158 given symbol can be a macro or a function, but not both at once, because | |
159 both macro and function definitions are kept in the function cell, and | |
160 that cell can hold only one Lisp object at any given time. | |
161 @xref{Macros}. | |
162 | |
163 In GNU Emacs Lisp, a definition is not required in order to use a | |
164 symbol as a variable or function. Thus, you can make a symbol a global | |
165 variable with @code{setq}, whether you define it first or not. The real | |
166 purpose of definitions is to guide programmers and programming tools. | |
167 They inform programmers who read the code that certain symbols are | |
168 @emph{intended} to be used as variables, or as functions. In addition, | |
169 utilities such as @file{etags} and @file{make-docfile} recognize | |
170 definitions, and add appropriate information to tag tables and the | |
171 @file{emacs/etc/DOC-@var{version}} file. @xref{Accessing Documentation}. | |
172 | |
173 @node Creating Symbols, Property Lists, Definitions, Symbols | |
174 @section Creating and Interning Symbols | |
175 @cindex reading symbols | |
176 | |
177 To understand how symbols are created in GNU Emacs Lisp, you must know | |
178 how Lisp reads them. Lisp must ensure that it finds the same symbol | |
179 every time it reads the same set of characters. Failure to do so would | |
180 cause complete confusion. | |
181 | |
182 @cindex symbol name hashing | |
183 @cindex hashing | |
184 @cindex obarray | |
185 @cindex bucket (in obarray) | |
186 When the Lisp reader encounters a symbol, it reads all the characters | |
187 of the name. Then it ``hashes'' those characters to find an index in a | |
188 table called an @dfn{obarray}. Hashing is an efficient method of | |
189 looking something up. For example, instead of searching a telephone | |
190 book cover to cover when looking up Jan Jones, you start with the J's | |
191 and go from there. That is a simple version of hashing. Each element | |
192 of the obarray is a @dfn{bucket} which holds all the symbols with a | |
193 given hash code; to look for a given name, it is sufficient to look | |
194 through all the symbols in the bucket for that name's hash code. | |
195 | |
196 @cindex interning | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
197 If a symbol with the desired name is found, the reader uses that |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
198 symbol. If the obarray does not contain a symbol with that name, the |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
199 reader makes a new symbol and adds it to the obarray. Finding or adding |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
200 a symbol with a certain name is called @dfn{interning} it, and the |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
201 symbol is then called an @dfn{interned symbol}. |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
202 |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
203 Interning ensures that each obarray has just one symbol with any |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
204 particular name. Other like-named symbols may exist, but not in the |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
205 same obarray. Thus, the reader gets the same symbols for the same |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
206 names, as long as you keep reading with the same obarray. |
6411 | 207 |
208 @cindex symbol equality | |
209 @cindex uninterned symbol | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
210 No obarray contains all symbols; in fact, some symbols are not in any |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
211 obarray. They are called @dfn{uninterned symbols}. An uninterned |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
212 symbol has the same four cells as other symbols; however, the only way |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
213 to gain access to it is by finding it in some other object or as the |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
214 value of a variable. |
6411 | 215 |
216 In Emacs Lisp, an obarray is actually a vector. Each element of the | |
217 vector is a bucket; its value is either an interned symbol whose name | |
218 hashes to that bucket, or 0 if the bucket is empty. Each interned | |
219 symbol has an internal link (invisible to the user) to the next symbol | |
220 in the bucket. Because these links are invisible, there is no way to | |
221 find all the symbols in an obarray except using @code{mapatoms} (below). | |
222 The order of symbols in a bucket is not significant. | |
223 | |
224 In an empty obarray, every element is 0, and you can create an obarray | |
225 with @code{(make-vector @var{length} 0)}. @strong{This is the only | |
226 valid way to create an obarray.} Prime numbers as lengths tend | |
227 to result in good hashing; lengths one less than a power of two are also | |
228 good. | |
229 | |
230 @strong{Do not try to put symbols in an obarray yourself.} This does | |
231 not work---only @code{intern} can enter a symbol in an obarray properly. | |
232 @strong{Do not try to intern one symbol in two obarrays.} This would | |
233 garble both obarrays, because a symbol has just one slot to hold the | |
234 following symbol in the obarray bucket. The results would be | |
235 unpredictable. | |
236 | |
237 It is possible for two different symbols to have the same name in | |
238 different obarrays; these symbols are not @code{eq} or @code{equal}. | |
239 However, this normally happens only as part of the abbrev mechanism | |
240 (@pxref{Abbrevs}). | |
241 | |
242 @cindex CL note---symbol in obarrays | |
243 @quotation | |
7734 | 244 @b{Common Lisp note:} In Common Lisp, a single symbol may be interned in |
6411 | 245 several obarrays. |
246 @end quotation | |
247 | |
248 Most of the functions below take a name and sometimes an obarray as | |
249 arguments. A @code{wrong-type-argument} error is signaled if the name | |
250 is not a string, or if the obarray is not a vector. | |
251 | |
252 @defun symbol-name symbol | |
253 This function returns the string that is @var{symbol}'s name. For example: | |
254 | |
255 @example | |
256 @group | |
257 (symbol-name 'foo) | |
258 @result{} "foo" | |
259 @end group | |
260 @end example | |
261 | |
262 Changing the string by substituting characters, etc, does change the | |
263 name of the symbol, but fails to update the obarray, so don't do it! | |
264 @end defun | |
265 | |
266 @defun make-symbol name | |
267 This function returns a newly-allocated, uninterned symbol whose name is | |
268 @var{name} (which must be a string). Its value and function definition | |
269 are void, and its property list is @code{nil}. In the example below, | |
270 the value of @code{sym} is not @code{eq} to @code{foo} because it is a | |
271 distinct uninterned symbol whose name is also @samp{foo}. | |
272 | |
273 @example | |
274 (setq sym (make-symbol "foo")) | |
275 @result{} foo | |
276 (eq sym 'foo) | |
277 @result{} nil | |
278 @end example | |
279 @end defun | |
280 | |
281 @defun intern name &optional obarray | |
282 This function returns the interned symbol whose name is @var{name}. If | |
283 there is no such symbol in the obarray @var{obarray}, @code{intern} | |
284 creates a new one, adds it to the obarray, and returns it. If | |
285 @var{obarray} is omitted, the value of the global variable | |
286 @code{obarray} is used. | |
287 | |
288 @example | |
289 (setq sym (intern "foo")) | |
290 @result{} foo | |
291 (eq sym 'foo) | |
292 @result{} t | |
293 | |
294 (setq sym1 (intern "foo" other-obarray)) | |
295 @result{} foo | |
296 (eq sym 'foo) | |
297 @result{} nil | |
298 @end example | |
299 @end defun | |
300 | |
301 @defun intern-soft name &optional obarray | |
302 This function returns the symbol in @var{obarray} whose name is | |
303 @var{name}, or @code{nil} if @var{obarray} has no symbol with that name. | |
304 Therefore, you can use @code{intern-soft} to test whether a symbol with | |
305 a given name is already interned. If @var{obarray} is omitted, the | |
306 value of the global variable @code{obarray} is used. | |
307 | |
308 @smallexample | |
309 (intern-soft "frazzle") ; @r{No such symbol exists.} | |
310 @result{} nil | |
311 (make-symbol "frazzle") ; @r{Create an uninterned one.} | |
312 @result{} frazzle | |
313 (intern-soft "frazzle") ; @r{That one cannot be found.} | |
314 @result{} nil | |
315 (setq sym (intern "frazzle")) ; @r{Create an interned one.} | |
316 @result{} frazzle | |
317 (intern-soft "frazzle") ; @r{That one can be found!} | |
318 @result{} frazzle | |
319 @group | |
320 (eq sym 'frazzle) ; @r{And it is the same one.} | |
321 @result{} t | |
322 @end group | |
323 @end smallexample | |
324 @end defun | |
325 | |
326 @defvar obarray | |
327 This variable is the standard obarray for use by @code{intern} and | |
328 @code{read}. | |
329 @end defvar | |
330 | |
331 @defun mapatoms function &optional obarray | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
332 This function calls @var{function} for each symbol in the obarray |
6411 | 333 @var{obarray}. It returns @code{nil}. If @var{obarray} is omitted, it |
334 defaults to the value of @code{obarray}, the standard obarray for | |
335 ordinary symbols. | |
336 | |
337 @smallexample | |
338 (setq count 0) | |
339 @result{} 0 | |
340 (defun count-syms (s) | |
341 (setq count (1+ count))) | |
342 @result{} count-syms | |
343 (mapatoms 'count-syms) | |
344 @result{} nil | |
345 count | |
346 @result{} 1871 | |
347 @end smallexample | |
348 | |
349 See @code{documentation} in @ref{Accessing Documentation}, for another | |
350 example using @code{mapatoms}. | |
351 @end defun | |
352 | |
353 @node Property Lists,, Creating Symbols, Symbols | |
354 @section Property Lists | |
355 @cindex property list | |
356 @cindex plist | |
357 | |
358 A @dfn{property list} (@dfn{plist} for short) is a list of paired | |
359 elements stored in the property list cell of a symbol. Each of the | |
360 pairs associates a property name (usually a symbol) with a property or | |
361 value. Property lists are generally used to record information about a | |
7118
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
362 symbol, such as its documentation as a variable, the name of the file |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
363 where it was defined, or perhaps even the grammatical class of the |
08d61ef58d13
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
6411
diff
changeset
|
364 symbol (representing a word) in a language-understanding system. |
6411 | 365 |
366 Character positions in a string or buffer can also have property lists. | |
367 @xref{Text Properties}. | |
368 | |
369 The property names and values in a property list can be any Lisp | |
370 objects, but the names are usually symbols. They are compared using | |
371 @code{eq}. Here is an example of a property list, found on the symbol | |
372 @code{progn} when the compiler is loaded: | |
373 | |
374 @example | |
375 (lisp-indent-function 0 byte-compile byte-compile-progn) | |
376 @end example | |
377 | |
378 @noindent | |
379 Here @code{lisp-indent-function} and @code{byte-compile} are property | |
380 names, and the other two elements are the corresponding values. | |
381 | |
382 @cindex property lists vs association lists | |
383 Association lists (@pxref{Association Lists}) are very similar to | |
384 property lists. In contrast to association lists, the order of the | |
385 pairs in the property list is not significant since the property names | |
386 must be distinct. | |
387 | |
388 Property lists are better than association lists for attaching | |
389 information to various Lisp function names or variables. If all the | |
390 associations are recorded in one association list, the program will need | |
391 to search that entire list each time a function or variable is to be | |
392 operated on. By contrast, if the information is recorded in the | |
393 property lists of the function names or variables themselves, each | |
394 search will scan only the length of one property list, which is usually | |
395 short. This is why the documentation for a variable is recorded in a | |
396 property named @code{variable-documentation}. The byte compiler | |
397 likewise uses properties to record those functions needing special | |
398 treatment. | |
399 | |
400 However, association lists have their own advantages. Depending on | |
401 your application, it may be faster to add an association to the front of | |
402 an association list than to update a property. All properties for a | |
403 symbol are stored in the same property list, so there is a possibility | |
404 of a conflict between different uses of a property name. (For this | |
405 reason, it is a good idea to choose property names that are probably | |
406 unique, such as by including the name of the library in the property | |
407 name.) An association list may be used like a stack where associations | |
408 are pushed on the front of the list and later discarded; this is not | |
409 possible with a property list. | |
410 | |
411 @defun symbol-plist symbol | |
412 This function returns the property list of @var{symbol}. | |
413 @end defun | |
414 | |
415 @defun setplist symbol plist | |
416 This function sets @var{symbol}'s property list to @var{plist}. | |
417 Normally, @var{plist} should be a well-formed property list, but this is | |
418 not enforced. | |
419 | |
420 @smallexample | |
421 (setplist 'foo '(a 1 b (2 3) c nil)) | |
422 @result{} (a 1 b (2 3) c nil) | |
423 (symbol-plist 'foo) | |
424 @result{} (a 1 b (2 3) c nil) | |
425 @end smallexample | |
426 | |
427 For symbols in special obarrays, which are not used for ordinary | |
428 purposes, it may make sense to use the property list cell in a | |
429 nonstandard fashion; in fact, the abbrev mechanism does so | |
430 (@pxref{Abbrevs}). | |
431 @end defun | |
432 | |
433 @defun get symbol property | |
434 This function finds the value of the property named @var{property} in | |
435 @var{symbol}'s property list. If there is no such property, @code{nil} | |
436 is returned. Thus, there is no distinction between a value of | |
437 @code{nil} and the absence of the property. | |
438 | |
439 The name @var{property} is compared with the existing property names | |
440 using @code{eq}, so any object is a legitimate property. | |
441 | |
442 See @code{put} for an example. | |
443 @end defun | |
444 | |
445 @defun put symbol property value | |
446 This function puts @var{value} onto @var{symbol}'s property list under | |
447 the property name @var{property}, replacing any previous property value. | |
448 The @code{put} function returns @var{value}. | |
449 | |
450 @smallexample | |
451 (put 'fly 'verb 'transitive) | |
452 @result{}'transitive | |
453 (put 'fly 'noun '(a buzzing little bug)) | |
454 @result{} (a buzzing little bug) | |
455 (get 'fly 'verb) | |
456 @result{} transitive | |
457 (symbol-plist 'fly) | |
458 @result{} (verb transitive noun (a buzzing little bug)) | |
459 @end smallexample | |
460 @end defun |