1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
| | @c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
@c Copyright (C) 1990--1995, 1998--1999, 2001--2023 Free Software
@c Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@node Symbols
@chapter Symbols
@cindex symbol
A @dfn{symbol} is an object with a unique name. This chapter
describes symbols, their components, their property lists, and how they
are created and interned. Separate chapters describe the use of symbols
as variables and as function names; see @ref{Variables}, and
@ref{Functions}. For the precise read syntax for symbols, see
@ref{Symbol Type}.
You can test whether an arbitrary Lisp object is a symbol with
@code{symbolp}:
@defun symbolp object
This function returns @code{t} if @var{object} is a symbol, @code{nil}
otherwise.
@end defun
@menu
* Symbol Components:: Symbols have names, values, function definitions
and property lists.
* Definitions:: A definition says how a symbol will be used.
* Creating Symbols:: How symbols are kept unique.
* Symbol Properties:: Each symbol has a property list
for recording miscellaneous information.
* Shorthands:: Properly organize your symbol names but
type less of them.
* Symbols with Position:: Symbol variants containing integer positions
@end menu
@node Symbol Components
@section Symbol Components
@cindex symbol components
Each symbol has four components (or ``cells''), each of which
references another object:
@table @asis
@item Print name
@cindex print name cell
The symbol's name.
@item Value
@cindex value cell
The symbol's current value as a variable.
@item Function
@cindex function cell
The symbol's function definition. It can also hold a symbol, a
keymap, or a keyboard macro.
@item Property list
@cindex property list cell
The symbol's property list.
@end table
@noindent
The print name cell always holds a string, and cannot be changed.
Each of the other three cells can be set to any Lisp object.
The print name cell holds the string that is the name of a symbol.
Since symbols are represented textually by their names, it is
important not to have two symbols with the same name. The Lisp reader
ensures this: every time it reads a symbol, it looks for an existing
symbol with the specified name before it creates a new one. To get a
symbol's name, use the function @code{symbol-name} (@pxref{Creating
Symbols}). However, although each symbol has only one unique
@emph{print name}, it is nevertheless possible to refer to that same
symbol via different alias names called ``shorthands''
(@pxref{Shorthands}).
The value cell holds a symbol's value as a variable, which is what
you get if the symbol itself is evaluated as a Lisp expression.
@xref{Variables}, for details about how values are set and retrieved,
including complications such as @dfn{local bindings} and @dfn{scoping
rules}. Most symbols can have any Lisp object as a value, but certain
special symbols have values that cannot be changed; these include
@code{nil} and @code{t}, and any symbol whose name starts with
@samp{:} (those are called @dfn{keywords}). @xref{Constant
Variables}.
The function cell holds a symbol's function definition. Often, we
refer to ``the function @code{foo}'' when we really mean the function
stored in the function cell of @code{foo}; we make the distinction
explicit only when necessary. Typically, the function cell is used to
hold a function (@pxref{Functions}) or a macro (@pxref{Macros}).
However, it can also be used to hold a symbol (@pxref{Function
Indirection}), keyboard macro (@pxref{Keyboard Macros}), keymap
(@pxref{Keymaps}), or autoload object (@pxref{Autoloading}). To get
the contents of a symbol's function cell, use the function
@code{symbol-function} (@pxref{Function Cells}).
The property list cell normally should hold a correctly formatted
property list. To get a symbol's property list, use the function
@code{symbol-plist}. @xref{Symbol Properties}.
The function cell or the value cell may be @dfn{void}, which means
that the cell does not reference any object. (This is not the same
thing as holding the symbol @code{void}, nor the same as holding the
symbol @code{nil}.) Examining a function or value cell that is void
results in an error, such as @samp{Symbol's value as variable is void}.
Because each symbol has separate value and function cells, variables
names and function names do not conflict. For example, the symbol
@code{buffer-file-name} has a value (the name of the file being
visited in the current buffer) as well as a function definition (a
primitive function that returns the name of the file):
@example
buffer-file-name
@result{} "/gnu/elisp/symbols.texi"
(symbol-function 'buffer-file-name)
@result{} #<subr buffer-file-name>
@end example
@node Definitions
@section Defining Symbols
@cindex definitions of symbols
A @dfn{definition} is a special kind of Lisp expression that
announces your intention to use a symbol in a particular way. It
typically specifies a value or meaning for the symbol for one kind of
use, plus documentation for its meaning when used in this way. Thus,
when you define a symbol as a variable, you can supply an initial
value for the variable, plus documentation for the variable.
@code{defvar} and @code{defconst} are special forms that define a
symbol as a @dfn{global variable}---a variable that can be accessed at
any point in a Lisp program. @xref{Variables}, for details about
variables. To define a customizable variable, use the
@code{defcustom} macro, which also calls @code{defvar} as a subroutine
(@pxref{Customization}).
In principle, you can assign a variable value to any symbol with
@code{setq}, whether or not it has first been defined as a variable.
However, you ought to write a variable definition for each global
variable that you want to use; otherwise, your Lisp program may not
act correctly if it is evaluated with lexical scoping enabled
(@pxref{Variable Scoping}).
@code{defun} defines a symbol as a function, creating a lambda
expression and storing it in the function cell of the symbol. This
lambda expression thus becomes the function definition of the symbol.
(The term ``function definition'', meaning the contents of the function
cell, is derived from the idea that @code{defun} gives the symbol its
definition as a function.) @code{defsubst} and @code{defalias} are two
other ways of defining a function. @xref{Functions}.
@code{defmacro} defines a symbol as a macro. It creates a macro
object and stores it in the function cell of the symbol. Note that a
given symbol can be a macro or a function, but not both at once, because
both macro and function definitions are kept in the function cell, and
that cell can hold only one Lisp object at any given time.
@xref{Macros}.
As previously noted, Emacs Lisp allows the same symbol to be defined
both as a variable (e.g., with @code{defvar}) and as a function or
macro (e.g., with @code{defun}). Such definitions do not conflict.
These definitions also act as guides for programming tools. For
example, the @kbd{C-h f} and @kbd{C-h v} commands create help buffers
containing links to the relevant variable, function, or macro
definitions. @xref{Name Help,,, emacs, The GNU Emacs Manual}.
@node Creating Symbols
@section Creating and Interning Symbols
@cindex reading symbols
To understand how symbols are created in GNU Emacs Lisp, you must
know how Lisp reads them. Lisp must ensure that it finds the same
symbol every time it reads the same sequence of characters in the same
context. Failure to do so would cause complete confusion.
@cindex symbol name hashing
@cindex hashing
@cindex obarray
@cindex bucket (in obarray)
When the Lisp reader encounters a name that references a symbol in
the source code, it reads all the characters of that name. Then it
looks up that name in a table called an @dfn{obarray} to find the
symbol that the programmer meant. The technique used in this lookup
is called ``hashing'', an efficient method of looking something up by
converting a sequence of characters to a number, known as a ``hash
code''. For example, instead of searching a telephone book cover to
cover when looking up Jan Jones, you start with the J's and go from
there. That is a simple version of hashing. Each element of the
obarray is a @dfn{bucket} which holds all the symbols with a given
hash code; to look for a given name, it is sufficient to look through
all the symbols in the bucket for that name's hash code. (The same
idea is used for general Emacs hash tables, but they are a different
data type; see @ref{Hash Tables}.)
When looking up names, the Lisp reader also considers ``shorthands''.
If the programmer supplied them, this allows the reader to find a
symbol even if its name isn't present in its full form in the source
code. Of course, the reader needs to be aware of some pre-established
context about such shorthands, much as one needs context to be to able
to refer uniquely to Jan Jones by just the name ``Jan'': it's probably
fine when amongst the Joneses, or when Jan has been mentioned
recently, but very ambiguous in any other situation.
@xref{Shorthands}.
@cindex interning
If a symbol with the desired name is found, the reader uses that
symbol. If the obarray does not contain a symbol with that name, the
reader makes a new symbol and adds it to the obarray. Finding or adding
a symbol with a certain name is called @dfn{interning} it, and the
symbol is then called an @dfn{interned symbol}.
Interning ensures that each obarray has just one symbol with any
particular name. Other like-named symbols may exist, but not in the
same obarray. Thus, the reader gets the same symbols for the same
names, as long as you keep reading with the same obarray.
Interning usually happens automatically in the reader, but sometimes
other programs may want to do it. For example, after the @kbd{M-x}
command obtains the command name as a string using the minibuffer, it
then interns the string, to get the interned symbol with that name.
As another example, a hypothetical telephone book program could intern
the name of each looked up person's name as a symbol, even if the
obarray did not contain it, so that it could attach information to
that new symbol, such as the last time someone looked it up.
@cindex symbol equality
@cindex uninterned symbol
No obarray contains all symbols; in fact, some symbols are not in any
obarray. They are called @dfn{uninterned symbols}. An uninterned
symbol has the same four cells as other symbols; however, the only way
to gain access to it is by finding it in some other object or as the
value of a variable. Uninterned symbols are sometimes useful in
generating Lisp code, see below.
In Emacs Lisp, an obarray is actually a vector. Each element of the
vector is a bucket; its value is either an interned symbol whose name
hashes to that bucket, or 0 if the bucket is empty. Each interned
symbol has an internal link (invisible to the user) to the next symbol
in the bucket. Because these links are invisible, there is no way to
find all the symbols in an obarray except using @code{mapatoms} (below).
The order of symbols in a bucket is not significant.
In an empty obarray, every element is 0, so you can create an obarray
with @code{(make-vector @var{length} 0)}. @strong{This is the only
valid way to create an obarray.} Prime numbers as lengths tend
to result in good hashing; lengths one less than a power of two are also
good.
@strong{Do not try to put symbols in an obarray yourself.} This does
not work---only @code{intern} can enter a symbol in an obarray properly.
@cindex CL note---symbol in obarrays
@quotation
@b{Common Lisp note:} Unlike Common Lisp, Emacs Lisp does not provide
for interning the same name in several different ``packages'', thus
creating multiple symbols with the same name but different packages.
Emacs Lisp provides a different namespacing system called
``shorthands'' (@pxref{Shorthands}).
@end quotation
Most of the functions below take a name and sometimes an obarray as
arguments. A @code{wrong-type-argument} error is signaled if the name
is not a string, or if the obarray is not a vector.
@defun symbol-name symbol
This function returns the string that is @var{symbol}'s name. For example:
@example
@group
(symbol-name 'foo)
@result{} "foo"
@end group
@end example
@strong{Warning:} Never alter the string returned by that function.
Doing that might make Emacs dysfunctional, and might even crash Emacs.
@end defun
@cindex uninterned symbol, and generating Lisp code
Creating an uninterned symbol is useful in generating Lisp code,
because an uninterned symbol used as a variable in the code you
generate cannot clash with any variables used in other Lisp programs.
@defun make-symbol name
This function returns a newly-allocated, uninterned symbol whose name is
@var{name} (which must be a string). Its value and function definition
are void, and its property list is @code{nil}. In the example below,
the value of @code{sym} is not @code{eq} to @code{foo} because it is a
distinct uninterned symbol whose name is also @samp{foo}.
@example
(setq sym (make-symbol "foo"))
@result{} foo
(eq sym 'foo)
@result{} nil
@end example
@end defun
@defun gensym &optional prefix
This function returns a symbol using @code{make-symbol}, whose name is
made by appending @code{gensym-counter} to @var{prefix} and incrementing
that counter, guaranteeing that no two calls to this function will
generate a symbol with the same name. The prefix defaults to
@code{"g"}.
@end defun
To avoid problems when accidentally interning printed representation
of generated code (@pxref{Printed Representation}), it is recommended
to use @code{gensym} instead of @code{make-symbol}.
@defun intern name &optional obarray
This function returns the interned symbol whose name is @var{name}. If
there is no such symbol in the obarray @var{obarray}, @code{intern}
creates a new one, adds it to the obarray, and returns it. If
@var{obarray} is omitted, the value of the global variable
@code{obarray} is used.
@example
(setq sym (intern "foo"))
@result{} foo
(eq sym 'foo)
@result{} t
(setq sym1 (intern "foo" other-obarray))
@result{} foo
(eq sym1 'foo)
@result{} nil
@end example
@end defun
@cindex CL note---interning existing symbol
@quotation
@b{Common Lisp note:} In Common Lisp, you can intern an existing symbol
in an obarray. In Emacs Lisp, you cannot do this, because the argument
to @code{intern} must be a string, not a symbol.
@end quotation
@defun intern-soft name &optional obarray
This function returns the symbol in @var{obarray} whose name is
@var{name}, or @code{nil} if @var{obarray} has no symbol with that name.
Therefore, you can use @code{intern-soft} to test whether a symbol with
a given name is already interned. If @var{obarray} is omitted, the
value of the global variable @code{obarray} is used.
The argument @var{name} may also be a symbol; in that case,
the function returns @var{name} if @var{name} is interned
in the specified obarray, and otherwise @code{nil}.
@example
(intern-soft "frazzle") ; @r{No such symbol exists.}
@result{} nil
(make-symbol "frazzle") ; @r{Create an uninterned one.}
@result{} frazzle
@group
(intern-soft "frazzle") ; @r{That one cannot be found.}
@result{} nil
@end group
@group
(setq sym (intern "frazzle")) ; @r{Create an interned one.}
@result{} frazzle
@end group
@group
(intern-soft "frazzle") ; @r{That one can be found!}
@result{} frazzle
@end group
@group
(eq sym 'frazzle) ; @r{And it is the same one.}
@result{} t
@end group
@end example
@end defun
@defvar obarray
This variable is the standard obarray for use by @code{intern} and
@code{read}.
@end defvar
@defun mapatoms function &optional obarray
@anchor{Definition of mapatoms}
This function calls @var{function} once with each symbol in the obarray
@var{obarray}. Then it returns @code{nil}. If @var{obarray} is
omitted, it defaults to the value of @code{obarray}, the standard
obarray for ordinary symbols.
@example
(setq count 0)
@result{} 0
(defun count-syms (s)
(setq count (1+ count)))
@result{} count-syms
(mapatoms 'count-syms)
@result{} nil
count
@result{} 1871
@end example
See @code{documentation} in @ref{Accessing Documentation}, for another
example using @code{mapatoms}.
@end defun
@defun unintern symbol obarray
This function deletes @var{symbol} from the obarray @var{obarray}. If
@code{symbol} is not actually in the obarray, @code{unintern} does
nothing. If @var{obarray} is @code{nil}, the current obarray is used.
If you provide a string instead of a symbol as @var{symbol}, it stands
for a symbol name. Then @code{unintern} deletes the symbol (if any) in
the obarray which has that name. If there is no such symbol,
@code{unintern} does nothing.
If @code{unintern} does delete a symbol, it returns @code{t}. Otherwise
it returns @code{nil}.
@end defun
@node Symbol Properties
@section Symbol Properties
@cindex symbol property
A symbol may possess any number of @dfn{symbol properties}, which
can be used to record miscellaneous information about the symbol. For
example, when a symbol has a @code{risky-local-variable} property with
a non-@code{nil} value, that means the variable which the symbol names
is a risky file-local variable (@pxref{File Local Variables}).
Each symbol's properties and property values are stored in the
symbol's property list cell (@pxref{Symbol Components}), in the form
of a property list (@pxref{Property Lists}).
@menu
* Symbol Plists:: Accessing symbol properties.
* Standard Properties:: Standard meanings of symbol properties.
@end menu
@node Symbol Plists
@subsection Accessing Symbol Properties
The following functions can be used to access symbol properties.
@defun get symbol property
This function returns the value of the property named @var{property}
in @var{symbol}'s property list. If there is no such property, it
returns @code{nil}. Thus, there is no distinction between a value of
@code{nil} and the absence of the property.
The name @var{property} is compared with the existing property names
using @code{eq}, so any object is a legitimate property.
See @code{put} for an example.
@end defun
@defun put symbol property value
This function puts @var{value} onto @var{symbol}'s property list under
the property name @var{property}, replacing any previous property value.
The @code{put} function returns @var{value}.
@example
(put 'fly 'verb 'transitive)
@result{}'transitive
(put 'fly 'noun '(a buzzing little bug))
@result{} (a buzzing little bug)
(get 'fly 'verb)
@result{} transitive
(symbol-plist 'fly)
@result{} (verb transitive noun (a buzzing little bug))
@end example
@end defun
@defun symbol-plist symbol
This function returns the property list of @var{symbol}.
@end defun
@defun setplist symbol plist
This function sets @var{symbol}'s property list to @var{plist}.
Normally, @var{plist} should be a well-formed property list, but this is
not enforced. The return value is @var{plist}.
@example
(setplist 'foo '(a 1 b (2 3) c nil))
@result{} (a 1 b (2 3) c nil)
(symbol-plist 'foo)
@result{} (a 1 b (2 3) c nil)
@end example
For symbols in special obarrays, which are not used for ordinary
purposes, it may make sense to use the property list cell in a
nonstandard fashion; in fact, the abbrev mechanism does so
(@pxref{Abbrevs}).
You could define @code{put} in terms of @code{setplist} and
@code{plist-put}, as follows:
@example
(defun put (symbol prop value)
(setplist symbol
(plist-put (symbol-plist symbol) prop value)))
@end example
@end defun
@defun function-get symbol property &optional autoload
This function is identical to @code{get}, except that if @var{symbol}
is the name of a function alias, it looks in the property list of the
symbol naming the actual function. @xref{Defining Functions}. If the
optional argument @var{autoload} is non-@code{nil}, and @var{symbol}
is auto-loaded, this function will try to autoload it, since
autoloading might set @var{property} of @var{symbol}. If
@var{autoload} is the symbol @code{macro}, only try autoloading if
@var{symbol} is an auto-loaded macro.
@end defun
@defun function-put function property value
This function sets @var{property} of @var{function} to @var{value}.
@var{function} should be a symbol. This function is preferred to
calling @code{put} for setting properties of a function, because it
will allow us some day to implement remapping of old properties to new
ones.
@end defun
@node Standard Properties
@subsection Standard Symbol Properties
Here, we list the symbol properties which are used for special
purposes in Emacs. In the following table, whenever we say ``the
named function'', that means the function whose name is the relevant
symbol; similarly for ``the named variable'' etc.
@table @code
@item :advertised-binding
This property value specifies the preferred key binding, when showing
documentation, for the named function. @xref{Keys in Documentation}.
@item char-table-extra-slots
The value, if non-@code{nil}, specifies the number of extra slots in
the named char-table type. @xref{Char-Tables}.
@item customized-face
@itemx face-defface-spec
@itemx saved-face
@itemx theme-face
These properties are used to record a face's standard, saved,
customized, and themed face specs. Do not set them directly; they are
managed by @code{defface} and related functions. @xref{Defining
Faces}.
@item customized-value
@itemx saved-value
@itemx standard-value
@itemx theme-value
These properties are used to record a customizable variable's standard
value, saved value, customized-but-unsaved value, and themed values.
Do not set them directly; they are managed by @code{defcustom} and
related functions. @xref{Variable Definitions}.
@item definition-name
This property is used to find the definition of a symbol in the source
code, when it might be hard to find the definition by textual search
of the source file. For example, a @code{define-derived-mode}
(@pxref{Derived Modes}) might define a mode-specific function or a
variable implicitly; or your Lisp program might generate a run-time
call to @code{defun} to define a function (@pxref{Defining
Functions}). In these and similar cases, the @code{definition-name}
property of the symbol should be another symbol whose definition can
be found by textual search and whose code defines the original symbol.
In the example with @code{define-derived-mode}, the value of this
property of the functions and variables it defines should be the mode
symbol. The Emacs Help commands such as @kbd{C-h f} (@pxref{Help,,,
emacs, The GNU Emacs Manual}) use this property to show the definition
of a symbol via a button in the @file{*Help*} buffer where the
symbol's documentation is shown.
@item disabled
If the value is non-@code{nil}, the named function is disabled as a
command. @xref{Disabling Commands}.
@item face-documentation
The value stores the documentation string of the named face. This is
set automatically by @code{defface}. @xref{Defining Faces}.
@item history-length
The value, if non-@code{nil}, specifies the maximum minibuffer history
length for the named history list variable. @xref{Minibuffer
History}.
@item interactive-form
The value is an interactive form for the named function. Normally,
you should not set this directly; use the @code{interactive} special
form instead. @xref{Interactive Call}.
@item menu-enable
The value is an expression for determining whether the named menu item
should be enabled in menus. @xref{Simple Menu Items}.
@item mode-class
If the value is @code{special}, the named major mode is special.
@xref{Major Mode Conventions}.
@item permanent-local
If the value is non-@code{nil}, the named variable is a buffer-local
variable whose value should not be reset when changing major modes.
@xref{Creating Buffer-Local}.
@item permanent-local-hook
If the value is non-@code{nil}, the named function should not be
deleted from the local value of a hook variable when changing major
modes. @xref{Setting Hooks}.
@item pure
@cindex @code{pure} property
If the value is non-@code{nil}, the named function is considered to be
pure (@pxref{What Is a Function}). Calls with constant arguments can
be evaluated at compile time. This may shift run time errors to
compile time. Not to be confused with pure storage (@pxref{Pure
Storage}).
@item risky-local-variable
If the value is non-@code{nil}, the named variable is considered risky
as a file-local variable. @xref{File Local Variables}.
@item safe-function
If the value is non-@code{nil}, the named function is considered
generally safe for evaluation. @xref{Function Safety}.
@item safe-local-eval-function
If the value is non-@code{nil}, the named function is safe to call in
file-local evaluation forms. @xref{File Local Variables}.
@item safe-local-variable
The value specifies a function for determining safe file-local values
for the named variable. @xref{File Local Variables}. Since this
value is consulted when loading files, the function should be
efficient and should ideally not lead to loading any libraries to
determine the safeness (e.g., it should not be an autoloaded function).
@item side-effect-free
@cindex @code{side-effect-free} property
A non-@code{nil} value indicates that the named function is free of
side effects (@pxref{What Is a Function}), so the byte compiler may
ignore a call whose value is unused. If the property's value is
@code{error-free}, the byte compiler may even delete such unused
calls. In addition to byte compiler optimizations, this property is
also used for determining function safety (@pxref{Function Safety}).
@item important-return-value
@cindex @code{important-return-value} property
A non-@code{nil} value makes the byte compiler warn about code that
calls the named function without using its returned value. This is
useful for functions where doing so is likely to be a mistake.
@item undo-inhibit-region
If non-@code{nil}, the named function prevents the @code{undo} operation
from being restricted to the active region, if @code{undo} is invoked
immediately after the function. @xref{Undo}.
@item variable-documentation
If non-@code{nil}, this specifies the named variable's documentation
string. This is set automatically by @code{defvar} and related
functions. @xref{Defining Faces}.
@end table
@node Shorthands
@section Shorthands
@cindex shorthands
@cindex symbolic shorthands
@cindex namespacing
@cindex namespaces
The symbol @dfn{shorthands}, sometimes known as ``renamed symbols'', are
symbolic forms found in Lisp source. They're just like regular
symbolic forms, except that when the Lisp reader encounters them, it
produces symbols which have a different and usually longer @dfn{print
name} (@pxref{Symbol Components}).
It is useful to think of shorthands as @emph{abbreviating} the full
names of intended symbols. Despite this, do not confuse shorthands with the
Abbrev system @pxref{Abbrevs}.
@cindex namespace etiquette
Shorthands make Emacs Lisp's @dfn{namespacing etiquette} easier to work
with. Since all symbols are stored in a single obarray
(@pxref{Creating Symbols}), programmers commonly prefix each symbol
name with the name of the library where it originates. For example,
the functions @code{text-property-search-forward} and
@code{text-property-search-backward} both belong to the
@file{text-property-search.el} library (@pxref{Loading}). By properly
prefixing symbol names, one effectively prevents clashes between
similarly named symbols which belong to different libraries and thus do
different things. However, this practice commonly originates very
long symbols names, which are inconvenient to type and read after a
while. Shorthands solve these issues in a clean way.
@defvar read-symbol-shorthands
This variable's value is an alist whose elements have the form
@code{(@var{shorthand-prefix} . @var{longhand-prefix})}. Each element
instructs the Lisp reader to read every symbol form which starts with
@var{shorthand-prefix} as if it started with @var{longhand-prefix}
instead.
This variable may only be set in file-local variables (@pxref{File Variables, ,
Local Variables in Files, emacs, The GNU Emacs Manual}).
@end defvar
Here's an example of shorthands usage in a hypothetical string
manipulating library @file{some-nice-string-utils.el}.
@smalllisp
(defun some-nice-string-utils-split (separator s &optional omit-nulls)
"A match-data saving variant of `split-string'."
(save-match-data (split-string s separator omit-nulls)))
(defun some-nice-string-utils-lines (s)
"Split string S at newline characters into a list of strings."
(some-nice-string-utils-split "\\(\r\n\\|[\n\r]\\)" s))
@end smalllisp
As can be seen, it's quite tedious to read or develop this code since
the symbol names to type are so long. We can use shorthands to
alleviate that.
@lisp
(defun snu-split (separator s &optional omit-nulls)
"A match-data saving variation on `split-string'."
(save-match-data (split-string s separator omit-nulls)))
(defun snu-lines (s)
"Split string S into a list of strings on newline characters."
(snu-split "\\(\r\n\\|[\n\r]\\)" s))
;; Local Variables:
;; read-symbol-shorthands: (("snu-" . "some-nice-string-utils-"))
;; End:
@end lisp
Even though the two excerpts look different, they are quite identical
after the Lisp reader processes them. Both will lead to the very same
symbols being interned (@pxref{Creating Symbols}). Thus loading or
byte-compiling any of the two files has equivalent results. The
shorthands @code{snu-split} and @code{snu-lines} used in the second
version are @emph{not} interned in the obarray. This is easily seen
by moving point to the location where the shorthands are used and
waiting for ElDoc (@pxref{Programming Language Doc, , Local Variables
in Files, emacs, The GNU Emacs Manual}) to hint at the true full name
of the symbol under point in the echo area.
Since @code{read-symbol-shorthands} is a file-local variable, it is
possible that multiple libraries depending on
@file{some-nice-string-utils-lines.el} refer to the same symbols under
@emph{different} shorthands, or not using shorthands at all. In the
next example, the @file{my-tricks.el} library refers to the symbol
@code{some-nice-string-utils-lines} using the @code{sns-} prefix
instead of @code{snu-}.
@example
(defun t-reverse-lines (s) (string-join (reverse (sns-lines s)) "\n")
;; Local Variables:
;; read-symbol-shorthands: (("t-" . "my-tricks-")
;; ("sns-" . "some-nice-string-utils-"))
;; End:
@end example
@subsection Exceptions
There are two exceptions to rules governing Shorthand transformations:
@itemize @bullet
@item
Symbol forms comprised entirely of characters in the Emacs Lisp symbol
constituent class (@pxref{Syntax Class Table}) are not transformed.
For example, it's possible to use @code{-} or @code{/=} as shorthand
prefixes, but that won't shadow the arithmetic @emph{functions} of
those names.
@item
Symbol forms whose names start with @samp{#_} are not transformed.
@end itemize
@node Symbols with Position
@section Symbols with Position
@cindex symbol with position
@cindex bare symbol
A @dfn{symbol with position} is a pair of a symbol, the @dfn{bare
symbol}, together with an unsigned integer called the @dfn{position}.
Symbol with position cannot themselves have entries in obarrays
(contrary to their bare symbols; @pxref{Creating Symbols}).
Symbols with position are for the use of the byte compiler, which
records in them the position of each symbol occurrence and uses those
positions in warning and error messages. They shouldn't normally be
used otherwise. Doing so can cause unexpected results with basic
Emacs functions such as @code{eq} and @code{equal}.
The printed representation of a symbol with position uses the hash
notation outlined in @ref{Printed Representation}. It looks like
@samp{#<symbol foo at 12345>}. It has no read syntax. You can cause
just the bare symbol to be printed by binding the variable
@code{print-symbols-bare} to non-@code{nil} around the print
operation. The byte compiler does this before writing its output to
the compiled Lisp file.
For most purposes, when the flag variable
@code{symbols-with-pos-enabled} is non-@code{nil}, symbols with
position behave just as their bare symbols would. For example,
@samp{(eq #<symbol foo at 12345> foo)} has a value @code{t} when the
variable is set; likewise, @code{equal} will treat a symbol with
position argument as its bare symbol.
When @code{symbols-with-pos-enabled} is @code{nil}, any symbols with
position continue to exist, but do not always behave as symbols.
Most importantly @code{eq} only returns @code{t} when given truly
identical arguments, for performance reasons. @code{equal} on the
other hand continues to treat a symbol with
position argument as its bare symbol.
Most of the time in Emacs @code{symbols-with-pos-enabled} is
@code{nil}, but the byte compiler and the native compiler bind it to
@code{t} when they run.
Typically, symbols with position are created by the byte compiler
calling the reader function @code{read-positioning-symbols}
(@pxref{Input Functions}). One can also be created with the function
@code{position-symbol}.
@defvar symbols-with-pos-enabled
When this variable is non-@code{nil}, symbols with position behave
like the contained bare symbol. Emacs runs a little more slowly in
this case.
@end defvar
@defvar print-symbols-bare
When bound to non-@code{nil}, the Lisp printer prints only the bare symbol of
a symbol with position, ignoring the position.
@end defvar
@defun symbol-with-pos-p symbol.
This function returns @code{t} if @var{symbol} is a symbol with
position, @code{nil} otherwise.
@end defun
@defun bare-symbol symbol
This function returns the bare symbol contained in @var{symbol}, or
@var{symbol} itself if it is already a bare symbol. For any other
type of object, it signals an error.
@end defun
@defun symbol-with-pos-pos symbol
This function returns the position, a number, from a symbol with
position. For any other type of object, it signals an error.
@end defun
@defun position-symbol sym pos
Make a new symbol with position. @var{sym} is either a bare symbol or
a symbol with position, and supplies the symbol part of the new
object. @var{pos} is either an integer which becomes the number part
of the new object, or a symbol with position whose position is used.
Emacs signals an error if either argument is invalid.
@end defun
|