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
|
@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
@c Copyright (C) 2017 Free Software
@c Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@node Records
@chapter Records
@cindex record
The purpose of records is to allow programmers to create objects
with new types that are not built into Emacs. They are used as the
underlying representation of @code{cl-defstruct} and @code{defclass}
instances.
Internally, a record object is much like a vector; its slots can be
accessed using @code{aref}. However, the first slot is used to hold
its type as returned by @code{type-of}. Like arrays, records use
zero-origin indexing: the first slot has index 0.
The printed representation of records is @samp{#s} followed by a
list specifying the contents. The first list element must be the
record type. The following elements are the record slots.
A record is considered a constant for evaluation: the result of
evaluating it is the same record. This does not evaluate or even
examine the slots. @xref{Self-Evaluating Forms}.
@menu
* Record Functions:: Functions for records.
@end menu
@node Record Functions
@section Record Functions
@defun recordp object
This function returns @code{t} if @var{object} is a record.
@example
@group
(recordp #s(a))
@result{} t
@end group
@end example
@end defun
@defun record type &rest objects
This function creates and returns a record whose type is @var{type}
and remaining slots are the rest of the arguments, @var{objects}.
@example
@group
(vector 'foo 23 [bar baz] "rats")
@result{} #s(foo 23 [bar baz] "rats")
@end group
@end example
@end defun
@defun make-record type length object
This function returns a new record with type @var{type} and
@var{length} more slots, each initialized to @var{object}.
@example
@group
(setq sleepy (make-record 'foo 9 'Z))
@result{} #s(foo Z Z Z Z Z Z Z Z Z)
@end group
@end example
@end defun
@defun copy-record record
This function returns a shallow copy of @var{record}. The copy is the
same type as the original record, and it has the same slots in the
same order.
Storing a new slot into the copy does not affect the original
@var{record}, and vice versa. However, the slots of the new record
are not copies; they are identical (@code{eq}) to the slots of the
original. Therefore, changes made within these slots, as found via
the copied record, are also visible in the original record.
@example
@group
(setq x (record 'foo 1 2))
@result{} #s(foo 1 2)
@end group
@group
(setq y (copy-record x))
@result{} #s(foo 1 2)
@end group
@group
(eq x y)
@result{} nil
@end group
@group
(equal x y)
@result{} t
@end group
@end example
@end defun
|
