Programming Language EuLisp
Version 0.991
WORKING DRAFT
______________________________________________________________________________________________________________________________________________________________________
The EULISP group first met in September 1985 at IRCAM in Paris to discuss the idea of a new dialect of Lisp, which should be less constrained by the past than Common Lisp and less minimalist than Scheme. Subsequent meetings formulated the view of EULISP that was presented at the 1986 ACM Conference on Lisp and Functional Programming held at MIT, Cambridge, Massachusetts [15] and at the European Conference on Artificial Intelligence (ECAI-86) held in Brighton, Sussex [22]. Since then, progress has not been steady, but happening as various people had sufficient time and energy to develop part of the language. Consequently, although the vision of the language has in the most part been shared over this period, only certain parts were turned into physical descriptions and implementations. For a nine month period starting in January 1989, through the support of INRIA, it became possible to start writing the EULISP definition. Since then, affairs have returned to their previous state, but with the evolution of the implementations of EULISP and the background of the foundations laid by the INRIA-supported work, there is convergence to a consistent and practical definition.
Work on this version started in 2010 from the material archived by Julian Padget in 1993 with the aim of finalising an EULISP-1.0 definition as close to the plans of the original contributors as is possible to ascertain from the remaining documents. If there is interest from any of the original contributors or others parties to participate in the process of finalising EULISP-1.0 your input would be greatly appreciated.
The acknowledgments for this definition fall into three categories: intellectual, personal, and financial.
The ancestors of EULISP (in alphabetical order) are Common Lisp [20], InterLISP [23], LE - LISP [4], LISP/VM [1], Scheme [6], and T [17] [18]. Thus, the authors of this report are pleased to acknowledge both the authors of the manuals and definitions of the above languages and the many who have dissected and extended those languages in individual papers. The various papers on Standard ML [14] and the draft report on Haskell [10] have also provided much useful input.
The writing of this report has, at various stages, been supported by Bull S.A., Gesellschaft für Mathematik und Datenverarbeitung (GMD, Sankt Augustin), Ecole Polytechnique (LIX), ILOG S.A., Institut National de Recherche en Informatique et en Automatique (INRIA), University of Bath, and Université Paris VI (LITP). The authors gratefully acknowledge this support. Many people from European Community countries have attended and contributed to EULISP meetings since they started, and the authors would like to thank all those who have helped in the development of the language.
In the beginning, the work of the EULISP group was supported by the institutions or companies where the participants worked, but in 1987 DG XIII (Information technology directorate) of the Commission of the European Communities agreed to support the continuation of the working group by funding meetings and providing places to meet. It can honestly be said that without this support EULISP would not have reached its present state. In addition, the EULISP group is grateful for the support of:
British Council in France (Alliance programme), British Council in Spain (Acciones Integradas programme), British Council in Germany (Academic Research Collaboration programme), British Standards Institute, Deutscher Akademischer Austauschdienst (DAAD), Departament de Llenguatges i Sistemes Informàtics (LSI, Universitat Politècnica de Catalunya), Fraunhofer Gesellschaft Institut für Software und Systemtechnik, Gesellschaft für Mathematik und Datenverarbeitung (GMD), ILOG S.A., Insiders GmbH, Institut National de Recherche en Informatique et en Automatique (INRIA), Institut de Recherche et de Coordination Acoustique Musique (IRCAM), Ministerio de Educacion y Ciencia (MEC), Rank Xerox France, Science and Engineering Research Council (UK), Siemens AG, University of Bath, University of Technology, Delft, University of Edinburgh, Universität Erlangen and Université Paris VI (LITP).
The following people (in alphabetical order) have contributed in various ways to the evolution of the language: Giuseppe Attardi, Javier Béjar, Neil Berrington, Russell Bradford, Harry Bretthauer, Peter Broadbery, Christopher Burdorf, Jérôme Chailloux, Odile Chenetier, Thomas Christaller, Jeff Dalton, Klaus Däßler, Harley Davis, David DeRoure, John Fitch, Richard Gabriel, Brigitte Glas, Nicolas Graube, Dieter Kolb, Jürgen Kopp, Antonio Moreno, Eugen Neidl, Greg Nuyens, Pierre Parquier, Keith Playford, Willem van der Poel, Christian Queinnec, Nitsan Seniak, Enric Sesa, Herbert Stoyan, and Richard Tobin.
The editors of the EULISP definition wish particularly to acknowledge the work of Harley Davis on the first versions of the description of the object system. The second version was largely the work of Harry Bretthauer, with the assistance of Jürgen Kopp, Harley Davis and Keith Playford.
Julian Padget (jap@maths.bath.ac.uk)
School of Mathematical Sciences
University of Bath
Bath, Avon, BA2 7AY, UK
Harry Bretthauer (harry.bretthauer@gmd.de) GMD mbH
Postfach 1316
53737 Sankt Augustin
Germany
original editors.
EULISP is a dialect of Lisp and as such owes much to the great body of work that has been done on language design in the name of Lisp over the last forty years. The distinguishing features of EULISP are (i) the integration of the classical Lisp type system and the object system into a single class hierarchy (ii) the complementary abstraction facilities provided by the class and the module mechanism (iii) support for concurrent execution.
Here is a brief summary of the main features of the language.
EULISP does not claim any particular Lisp dialect as its closest relative, although parts of it were influenced by features found in Common Lisp, InterLISP, LE-LISP, LISP/VM, Scheme, and T. EULISP both introduces new ideas and takes from these Lisps. It also extends or simplifies their ideas as seen fit. But this is not the place for a detailed language comparison. That can be drawn from the rest of this text.
EULISP breaks with LISP tradition in describing all its types (in fact, classes) in terms of an object system. This is called The EU LISP Object System, or TELOS. TELOS incorporates elements of the Common Lisp Object System (CLOS) [3], ObjVLisp [7], Oaklisp [12], MicroCeyx [5], and MCS [24].
character (level-0), 1
collection (level-0), 2
compare (level-0), 3
condition (level-0), 4
convert (level-0), 5
copy (level-0), 6
double-float (level-0), 7
dynamic (level-1), 8
exit-1 (level-1), 9
float (level-0), 10
formatted-io (level-0), 11
fpi (level-0), 12
integer (level-0), 13
keyword (level-0), 14
list (level-0), 15
lock (level-0), 16
mathlib (level-0), 17
number (level-0), 18
stream (level-0), 19
string (level-0), 20
symbol (level-0), 21
table (level-0), 22
telos0 (level-0), 23
thread (level-0), 24
vector (level-0), 25
<a-class> (undefined-module), 1
<buffered-stream> (stream), 2
<character> (character), 3
<character-sequence> (collection), 4
<class> (telos0), 5
<collection> (collection), 6
<condition> (condition), 7
<cons> (list), 8
<double-float> (double-float), 9
<file-stream> (stream), 10
<fixed-buffered-stream> (stream), 11
<float> (float), 12
<fpi> (fpi), 13
<function> (telos0), 14
<function-class> (level-1), 15
<generic-function> (telos0), 16
<hash-table> (table), 17
<integer> (integer), 18
<keyword> (keyword), 19
<list> (list), 20
<local-slot> (level-1), 21
<lock> (lock), 22
<metaclass> (level-1), 23
<method> (level-1), 24
<name> (telos0), 25
<null> (list), 26
<number> (number), 27
<object> (telos0), 28
<sequence> (collection), 29
<simple-class> (level-1), 30
<simple-function> (telos0), 31
<simple-generic-function> (telos0), 32
<simple-method> (level-1), 33
<simple-thread> (lock), 34
<slot> (level-1), 35
<stream> (stream), 36
<string> (character), 37
<string> (string), 38
<string-stream> (stream), 39
<symbol> (symbol), 40
<table> (table), 41
<thread> (thread), 42
<vector> (vector), 43
’ (level-0), 1
() (list), 2
, (syntax-0), 3
‘ (syntax-0), 4
a-special-form (undefined-module), 5
and (level-0), 6
block (level-0), 7
call-next-handler (condition), 8
call-next-method (telos0), 9
catch (exit-1), 10
character (character), 11
cond (level-0), 12
constant (level-0), 13
defclass (level-1), 14
defclass (telos0), 15
defcondition (condition), 16
defconstant (level-0), 17
defgeneric (level-1), 18
defgeneric (telos0), 19
defglobal (dynamic), 20
deflocal (level-0), 21
defmethod (level-1), 22
defmethod (telos0), 23
defmodule (), 24
defsyntax (level-0), 25
defun (level-0), 26
dynamic (dynamic), 27
dynamic-let (dynamic), 28
dynamic-setq (dynamic), 29
float (float), 30
function call (level-0), 31
generic-lambda (level-1), 32
generic-lambda (telos0), 33
if (level-0), 34
integer (integer), 35
keyword (keyword), 36
lambda (level-0), 37
let (level-0), 38
let* (level-0), 39
let/cc (level-0), 40
letfuns (level-0), 41
method-function-lambda (level-1), 42
method-lambda (level-1), 43
next-method? (telos0), 44
or (level-0), 45
pair (list), 46
progn (level-0), 47
quasiquote (syntax-0), 48
quote (level-0), 49
return-from (level-0), 50
setq (level-0), 51
string (string), 52
symbol (level-0), 53
symbol (symbol), 54
throw (exit-1), 55
unless (level-0), 56
unquote (syntax-0), 57
unquote-splicing (syntax-0), 58
unwind-protect (level-0), 59
vector (vector), 60
when (level-0), 61
with-handler (condition), 62
with-input-file (stream), 63
with-output-file (stream), 64
with-sink (stream), 65
with-source (stream), 66
* (number), 1
+ (number), 2
- (number), 3
/ (number), 4
< (compare), 5
<= (compare), 6
= (compare), 7
> (compare), 8
>= (compare), 9
% (number), 10
a-function (undefined-module), 11
abs (number), 12
abstract-class? (telos0), 13
allocate (telos0), 14
apply (level-0), 15
apply-method (level-1), 16
atom? (list), 17
call-method (level-1), 18
car (list), 19
cdr (list), 20
cerror (condition), 21
character? (character), 22
class-keywords (level-1), 23
class-name (level-1), 24
class-of (level-1), 25
class-precedence-list (level-1), 26
class-slots (level-1), 27
clear-table (table), 28
condition? (condition), 29
connect (stream), 30
cons (list), 31
cons? (list), 32
convert (convert), 33
converter (convert), 34
current-thread (thread), 35
double-float? (double-float), 36
eq (compare), 37
eql (compare), 38
error (condition), 39
file-stream-buffer-position (stream), 40
file-stream-filename (stream), 41
file-stream-mode (stream), 42
file-stream? (stream), 43
float? (float), 44
flush (stream), 45
fmt (formatted-io), 46
format (formatted-io), 47
from-stream (stream), 48
gcd (number), 49
generic-function-discriminating-function (level-1), 50
generic-function-domain (level-1), 51
generic-function-method-class (level-1), 52
generic-function-method-lookup-function (level-1), 53
generic-function-methods (level-1), 54
gensym (symbol), 55
int? (fpi), 56
integer? (integer), 57
keyword-exists? (keyword), 58
keyword-name (keyword), 59
keyword? (keyword), 60
lcm (number), 61
list (list), 62
lock (lock), 63
lock? (lock), 64
make (telos0), 65
max (compare), 66
method-domain (level-1), 67
method-function (level-1), 68
method-generic-function (level-1), 69
min (compare), 70
mod (number), 71
negative? (number), 72
null? (list), 73
number? (number), 74
odd? (integer), 75
open-input-file (stream), 76
open-output-file (stream), 77
positive? (number), 78
primitive-allocate (level-1), 79
primitive-class-of (level-1), 80
primitive-ref (level-1), 81
prin-char (stream), 82
print (stream), 83
read (stream), 84
read-line (stream), 85
scan (formatted-io), 86
setter (level-0), 87
(setter car) (list), 88
(setter cdr) (list), 89
(setter converter) (convert), 90
(setter element) (collection), 91
(setter method-function) (level-1), 92
(setter primitive-class-of) (level-1), 93
(setter primitive-ref) (level-1), 94
sflush (stream), 95
sformat (formatted-io), 96
signal (condition), 97
signum (number), 98
slot-default-function (level-1), 99
slot-name (level-1), 100
slot-slot-reader (level-1), 101
slot-slot-writer (level-1), 102
sprin-char (stream), 103
sprint (stream), 104
sread (stream), 105
stream-buffer (stream), 106
stream-buffer-size (stream), 107
stream-lock (stream), 108
stream-sink (stream), 109
stream-source (stream), 110
stream? (stream), 111
string-stream? (stream), 112
string? (string), 113
swrite (stream), 114
symbol-exists? (symbol), 115
symbol-name (symbol), 116
symbol? (symbol), 117
table? (table), 118
thread-reschedule (thread), 119
thread-start (thread), 120
thread-value (thread), 121
thread? (thread), 122
to-stream (stream), 123
unlock (lock), 124
vector? (vector), 125
write (stream), 126
a-generic, 1
defgeneric (undefined-module), 2
defmethod class-a (undefined-module), 3
accumulate, 4
defgeneric (collection), 5
accumulate1, 6
defgeneric (collection), 7
acos, 8
defgeneric (mathlib), 9
add-method, 10
defgeneric (level-1), 11
defmethod generic-function (level-1), 12
all?, 13
defgeneric (collection), 14
allocate, 15
defgeneric (level-1), 16
defmethod class (level-1), 17
any?, 18
defgeneric (collection), 19
as-lowercase, 20
defgeneric (character), 21
defmethod character (character), 22
defmethod string (string), 23
as-uppercase, 24
defgeneric (character), 25
defmethod character (character), 26
defmethod string (string), 27
asin, 28
defgeneric (mathlib), 29
atan, 30
defgeneric (mathlib), 31
atan2, 32
defgeneric (mathlib), 33
binary*, 34
defgeneric (number), 35
binary+, 36
defgeneric (number), 37
binary-, 38
defgeneric (number), 39
binary-gcd, 40
defgeneric (number), 41
binary-lcm, 42
defgeneric (number), 43
binary-mod, 44
defgeneric (number), 45
binary/, 46
defgeneric (number), 47
binary<, 48
defgeneric (compare), 49
defmethod character (character), 50
defmethod string (string), 51
binary=, 52
defgeneric (compare), 53
defmethod character (character), 54
defmethod cons (list), 55
defmethod number (number), 56
defmethod object (compare), 57
defmethod string (string), 58
defmethod vector (vector), 59
binary% , 60
defgeneric (number), 61
ceiling, 62
defgeneric (float), 63
collection?, 64
defgeneric (collection), 65
compatible-superclass?, 66
defgeneric (level-1), 67
defmethod abstract-class (level-1), 68, 69
defmethod class (level-1), 70, 71
compatible-superclasses?, 72
defgeneric (level-1), 73
defmethod class (level-1), 74
compute-and-ensure-slot-accessors, 75
defgeneric (level-1), 76
defmethod class (level-1), 77
compute-class-precedence-list, 78
defgeneric (level-1), 79
defmethod list (level-1), 80
compute-constructor, 81
defgeneric (level-1), 82
defmethod class (level-1), 83
compute-defined-slot, 84
defgeneric (level-1), 85
defmethod class (level-1), 86
compute-defined-slot-class, 87
defgeneric (level-1), 88
defmethod class (level-1), 89
compute-discriminating-function, 90
defgeneric (level-1), 91
defmethod generic-function (level-1), 92
compute-inherited-keywords, 93
defgeneric (level-1), 94
defmethod class (level-1), 95
compute-inherited-slots, 96
defgeneric (level-1), 97
defmethod class (level-1), 98
compute-keywords, 99
defgeneric (level-1), 100
defmethod class (level-1), 101
compute-method-lookup-function, 102
defgeneric (level-1), 103
defmethod generic-function (level-1), 104
compute-predicate, 105
defgeneric (level-1), 106
defmethod class (level-1), 107
compute-primitive-reader-using-class, 108
defgeneric (level-1), 109
defmethod class (level-1), 110, 111
compute-primitive-reader-using-slot, 112
defgeneric (level-1), 113
defmethod slot (level-1), 114
compute-primitive-writer-using-class, 115
defgeneric (level-1), 116
compute-primitive-writer-using-slot, 117
defgeneric (level-1), 118
defmethod slot (level-1), 119
compute-slot-reader, 120
defgeneric (level-1), 121
defmethod class (level-1), 122
compute-slot-writer, 123
defgeneric (level-1), 124
defmethod class (level-1), 125
compute-slots, 126
defgeneric (level-1), 127
defmethod class (level-1), 128
compute-specialized-slot, 129
defgeneric (level-1), 130
defmethod class (level-1), 131
compute-specialized-slot-class, 132
defgeneric (level-1), 133
defmethod class (level-1), 134
concatenate, 135
defgeneric (collection), 136
cos, 137
defgeneric (mathlib), 138
cosh, 139
defgeneric (mathlib), 140
deep-copy, 141
defgeneric (copy), 142
defmethod class (copy), 143
defmethod cons (list), 144
defmethod object (copy), 145
defmethod string (string), 146
defmethod vector (vector), 147
delete, 148
defgeneric (collection), 149
disconnect, 150
defgeneric (stream), 151
defmethod file-stream (stream), 152
defmethod stream (stream), 153
do, 154
defgeneric (collection), 155
element, 156
defgeneric (collection), 157
empty?, 158
defgeneric (collection), 159
end-of-stream, 160
defgeneric (stream), 161
defmethod buffered-stream (stream), 162
defmethod file-stream (stream), 163
ensure-slot-reader, 164
defgeneric (level-1), 165
defmethod class (level-1), 166
ensure-slot-writer, 167
defgeneric (level-1), 168
defmethod class (level-1), 169
even?, 170
defgeneric (integer), 171
exp, 172
defgeneric (mathlib), 173
fill, 174
defgeneric (collection), 175
fill-buffer, 176
defgeneric (stream), 177
defmethod buffered-stream (stream), 178
defmethod file-stream (stream), 179
find-key, 180
defgeneric (collection), 181
first, 182
defgeneric (collection), 183
floor, 184
defgeneric (float), 185
flush-buffer, 186
defgeneric (stream), 187
defmethod buffered-stream (stream), 188
defmethod file-stream (stream), 189
generic-connect, 190
defgeneric (stream), 191
defmethod file-stream (stream), 192
defmethod path (stream), 193
defmethod stream (stream), 194
generic-print, 195
defgeneric (stream), 196
defmethod character (character), 197
defmethod cons (list), 198
defmethod double-float (double-float), 199
defmethod fpi (fpi), 200
defmethod keyword (keyword), 201
defmethod null (list), 202
defmethod string (string), 203
defmethod symbol (symbol), 204
defmethod vector (vector), 205
generic-read, 206
defgeneric (stream), 207
defmethod buffered-stream (stream), 208
defmethod file-stream (stream), 209
defmethod stream (stream), 210
generic-write, 211
defgeneric (stream), 212
defmethod buffered-stream (stream), 213
defmethod character (character), 214
defmethod cons (list), 215
defmethod double-float (double-float), 216
defmethod file-stream (stream), 217
defmethod fpi (fpi), 218
defmethod keyword (keyword), 219
defmethod null (list), 220
defmethod stream (stream), 221
defmethod string (string), 222
defmethod symbol (symbol), 223
defmethod vector (vector), 224
initialize, 225
defgeneric (telos0), 226
defmethod class (level-1), 227
defmethod condition (condition), 228
defmethod generic-function (level-1), 229
defmethod method (level-1), 230
defmethod object (telos0), 231
defmethod slot (level-1), 232
key-sequence, 233
defgeneric (collection), 234
last, 235
defgeneric (collection), 236
log, 237
defgeneric (mathlib), 238
log10, 239
defgeneric (mathlib), 240
map, 241
defgeneric (collection), 242
member, 243
defgeneric (collection), 244
negate, 245
defgeneric (number), 246
pow, 247
defgeneric (mathlib), 248
reconnect, 249
defgeneric (stream), 250
defmethod stream (stream), 251
remove, 252
defgeneric (collection), 253
reverse, 254
defgeneric (collection), 255
round, 256
defgeneric (float), 257
sequence?, 258
defgeneric (collection), 259
shallow-copy, 260
defgeneric (copy), 261
defmethod class (copy), 262
defmethod cons (list), 263
defmethod object (copy), 264
defmethod string (string), 265
defmethod vector (vector), 266
sin, 267
defgeneric (mathlib), 268
sinh, 269
defgeneric (mathlib), 270
size, 271
defgeneric (collection), 272
slice, 273
defgeneric (collection), 274
sort, 275
defgeneric (collection), 276
sqrt, 277
defgeneric (mathlib), 278
tan, 279
defgeneric (mathlib), 280
tanh, 281
defgeneric (mathlib), 282
truncate, 283
defgeneric (float), 284
wait, 285
defgeneric (thread), 286
defmethod thread (thread), 287
zero?, 288
defgeneric (number), 289
<cannot-update-setter> (level-0), 1
a-condition (undefined-module), 2
arithmetic-condition (number), 3
cannot-update-setter (level-0), 4
collection-condition (collection), 5, 6
conversion-condition (collection), 7
conversion-condition (convert), 8
division-by-zero (number), 9, 10, 11, 12
domain-condition (condition), 13
domain-condition (mathlib), 14, 15, 16, 17, 18, 19, 20
dynamic-multiply-defined (dynamic), 21, 22
end-of-stream (stream), 23, 24
environment-condition (condition), 25
general-condition (condition), 26
generic-function-condition (condition), 27
incompatible-method-and-gf (level-1), 28
incompatible-method-domain (condition), 29
incompatible-method-domain (telos0), 30, 31
invalid-operator (level-0), 32, 33, 34
method-domain-clash (condition), 35
method-domain-clash (level-1), 36
method-domain-clash (telos0), 37, 38
no-applicable-method (condition), 39
no-applicable-method (convert), 40
no-applicable-method (telos0), 41
no-converter (convert), 42, 43
no-next-method (condition), 44
no-next-method (telos0), 45
non-congruent-lambda-lists (condition), 48
non-congruent-lambda-lists (level-1), 49
non-congruent-lambda-lists (telos0), 50, 51
range-condition (condition), 52
range-condition (mathlib), 53, 54, 55, 56, 57
read-error (stream), 58
scan-mismatch (formatted-io), 59, 60
thread-already-started (thread), 61, 62
thread-condition (thread), 63
unbound-dynamic-variable (dynamic), 64, 65, 66
wrong-condition-class (condition), 67, 68
wrong-thread-continuation (level-0), 69
wrong-thread-continuation (thread), 70
a-constant (undefined-module), 1
else (level-0), 2
least-negative-double-float (double-float), 3
least-positive-double-float (double-float), 4
maximum-vector-index (vector), 5
most-negative-double-float (double-float), 6
most-negative-int (fpi), 7
most-positive-double-float (double-float), 8
most-positive-int (fpi), 9
pi (mathlib), 10
t (level-0), 11
ticks-per-second (thread), 12
’, 1
(), 2
*, 3
+, 4
,, 5
-, 6
/, 7
<, 8
<=, 9
=, 10
>, 11
>=, 12
% , 13
‘, 14
<a-class>, 15
a-constant, 16
a-function, 17
function signature, 18
a-special-form, 21
syntax table, 22
abs, 23
abstract class, 24
abstract-class?, 25
function signature, 26
abstract?, 27
accessor, 28
accumulate, 29
accumulate1, 30
all?, 35
and, 39
rewrite rules, 40
syntax table, 41
any?, 42
applicable method, 43
apply, 44
syntax table, 45
apply-method, 46
assignment, 55
atom?, 60
backquoting, 61
base, 62
arbitrary base literals, 63
limitation on input, 64
binary literals, 65
binary=, 90, 91, 92, 93, 94, 95, 96, 97, 98
binding, 101
dynamically scoped, 102
module, 103
top dynamic, 106
block, 107
rewrite rules, 108
syntax table, 110
boolean
syntax table, 113
<buffered-stream>, 114
call-method, 115
call-next-handler, 116
syntax table, 117
call-next-method, 118
function signature, 119
car, 120
case sensitivity, 121
catch, 122
rewrite rules, 123
syntax table, 124
cdr, 125
cerror, 128
character, 129
character-extension glyph, 130
minimal character set, 131
module, 132
<character>, 133
character, 134
syntax table, 135
character set, 136
<character-sequence>, 137
character-set
syntax table, 138
character?, 139
primitive, 144
self-instantiated, 145
<class>, 146
class, 147
class option, 148
class precedence list, 149
class-keywords, 150
class-name, 151
class-of, 152
class-precedence-list, 153
class-slots, 154
clear-table, 155
CLOS, 156
closure, 157
coercion, 158
collection, 159
alignment, 160
module, 161
<collection>, 162
collection-condition, 163
collection?, 164
comment
syntax table, 165
comments, 166
line, 167
object, 168
Common Lisp Error System, 169
compare, 170
module, 171
compatible-superclass?, 172, 173, 174, 175, 176
compatible-superclasses?, 177, 178
compute-and-ensure-slot-accessors, 181, 182
compute-class-precedence-list, 183, 184
compute-defined-slot, 187, 188
compute-defined-slot-class, 189, 190
compute-discriminating-function, 191, 192
compute-inherited-keywords, 193, 194
compute-inherited-slots, 195, 196
compute-method-lookup-function, 199, 200
compute-primitive-reader-using-class, 203, 204, 205
compute-primitive-reader-using-slot, 206, 207
compute-primitive-writer-using-class, 208
compute-primitive-writer-using-slot, 209, 210
compute-specialized-slot, 217, 218
compute-specialized-slot-class, 219, 220
concatenate, 221
concurrency, 222
cond, 223
rewrite rules, 224
syntax table, 225
continuable, 228
module, 229
non-continuable, 230
<condition>, 231
condition?, 232
configuration, 233
conformance, 234
level-1, 237
conforming processor, 238
conforming program, 239
conformity clause, 240
conformity-clause
least negative double precision float, 241
least positive double precision float, 242
maximum vector index, 243
most negative double precision float, 244
most negative fixed precision integer, 245
most positive double precision float, 246
most positive fixed precision integer, 247, 248, 249
congruent, 250
connect, 251
<cons>, 252
cons, 253
cons?, 254
constant
a-constant, 255
defined, 256
else, 257
least-negative-double-float, 258
least-positive-double-float, 259
literal, 260
maximum-vector-index, 261
most-negative-double-float, 262
most-negative-int, 263
most-positive-double-float, 264
most-positive-int, 265
pi, 266
t, 267
ticks-per-second, 268
constructor, 271
conventions, 275
convert, 276
module, 277
convert, 278
converter, 279
converter function, 280
(converter <double-float>), 281
(converter <fpi>), 282
(converter <list>), 283
(converter <string>), 284, 285, 286, 287, 288
(converter <symbol>), 289
(converter <table>), 290
(converter <vector>), 291
copy, 292
module, 293
current-thread, 298
deep-copy, 299, 300, 301, 302, 303, 304
default, 305
default, 306
default-function, 307
syntax table, 310
defclass-1
syntax table, 311
defcondition, 312
syntax table, 313
defconstant, 314
syntax table, 315
rewrite rules, 319
syntax table, 320
defgeneric-1
syntax table, 321
defglobal, 322
syntax table, 323
defining operator, 326
defining-0-forms
syntax table, 327
deflocal, 328
syntax table, 329
syntax table, 332
defmethod-1
syntax table, 333
defmodule-0
syntax table, 336
defmodule-1
syntax table, 337
defsyntax, 338
syntax table, 339
defun, 340
rewrite rules, 341
syntax table, 342
delete, 343
direct instance, 344
direct subclass, 345
direct superclass, 346
do, 350
double-float, 351
module, 352
<double-float>, 353
double-float
syntax table, 354
double-float?, 355
dynamic, 356
module, 357
dynamic, 358
syntax table, 359
dynamic environment, 360
dynamic extent, 361
dynamic scope, 362
dynamic-let, 363
syntax table, 364
dynamic-setq, 365
syntax table, 366
element, 367
else, 368
empty?, 369
environmental error, 377
eq, 378
implementation-defined behaviour, 379
eql, 380
can be signalled, 383
environmental, 384
handler, 385
signalled, 386
static, 387
violation, 388
error, 389
errors, 390
EULISP
level-0, 391
level-1, 392
libraries, 393
except, 396
exit-1, 397
module, 398
extension, 405
extent, 406
external representation
floating point, 407
list, 410
null (empty list), 411
pair, 412
string, 413
vector, 414
external representation (see also ?? and write), 415
<file-stream>, 418
file-stream-buffer-position, 419
file-stream-filename, 420
file-stream-mode, 421
file-stream?, 422
fill, 423
find-key, 427
first, 428
first-class, 429
<fixed-buffered-stream>, 430
float, 431
module, 432
<float>, 433
float, 434
syntax table, 435
float?, 436
flush, 439
fmt, 443
format, 444
formatted-io, 445
module, 446
fpi, 447
module, 448
<fpi>, 449
from-stream, 450
function, 451
calling, 452
reader, 453
standard function, 454
writer, 455
<function>, 456
function call, 457
function signatures
a-function, 458
abstract-class?, 459
call-next-method, 460
next-method?, 461
function-call
syntax table, 462
<function-class>, 463
gcd, 464
generic function, 465
lambda-list, 466
rewrite rules, 467
generic-1-lambda
syntax table, 468
generic-connect, 469, 470, 471, 472
<generic-function>, 473
generic-function-discriminating-function, 474
generic-function-domain, 475
generic-function-method-class, 476
generic-function-method-lookup-function, 477
generic-function-methods, 478
syntax table, 482
generic-print, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492
generic-read, 493, 494, 495, 496
generic-write, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509
gensym, 510
<hash-table>, 511
hexadecimal literals, 514
definition of, 517
peculiar identifiers, 518
identifier
syntax table, 519
identifiers, 520
if, 521
syntax table, 522
implementation-defined, 523
least negative double precision float, 525
least positive double precision float, 526
maximum vector index, 527
module directives, 528
most negative double precision float, 529
most negative fixed precision integer, 530
most positive double precision float, 531
most positive fixed precision integer, 532, 533, 534
time units per second, 535
indefinite extent, 538
indirect instance, 539
indirect subclass, 540
inheritance
single, 543
inheritance graph, 544
inherited slot description, 545
init-list, 546
initialization, 547
initialize, 548, 549, 550, 551, 552, 553, 554
inner dynamic, 555
inner lexical, 556
instance, 557
direct, 558
indirect, 559
instantiation graph, 560
int?, 561
integer, 562
module, 563
<integer>, 564
integer, 565
syntax table, 566
integer?, 567
key-sequence, 570
abstract?, 574
accessor, 575
class, 576
constructor, 577
default, 578
definition of, 579
except, 580
keyword, 587
keywords, 588
method, 589
module, 590
only, 591
predicate, 592
reader, 593
rename, 594
required?, 595
writer, 598
<keyword>, 599
syntax table, 602
keyword-exists?, 603
keyword-name, 604
keyword?, 605
keywords, 606
lambda, 607
syntax table, 608
language structure, 609
last, 610
lcm, 611
least-negative-double-float, 612
least-positive-double-float, 613
LeLisp, 614
let, 617
rewrite rules, 618
syntax table, 619
let*, 620
rewrite rules, 621
syntax table, 622
let/cc, 623
see also block and return-from, 624
syntax table, 625
letfuns, 626
syntax table, 627
lexical environment, 630
lexical scope, 631
lexical syntax, 632
lispin, 633
module, 638
<list>, 639
list, 640
syntax table, 641
literal, 642
arbitrary base, 643
binary, 644
character, 645
hexadecimal, 646
modification of, 647
octal, 648
quotation, 649
<local-slot>, 650
lock, 651
module, 652
<lock>, 653
lock, 654
lock?, 655
make, 660
map, 661
mathlib, 662
module, 663
max, 664
maximum-vector-index, 665
MCS, 666
member, 667
metaclass, 668
<metaclass>, 669
method, 670
applicable, 671
bindings, 672
specificity, 673
<method>, 674
method, 675
method function, 676
method specificity, 677
method-domain, 678
method-function, 679
method-function-lambda, 680
method-generic-function, 681
method-lambda, 682
syntax table, 683
MicroCeyx, 684
min, 685
mod, 686
directives, 689
environments, 690
except, 691
export, 692
expose, 693
import, 694
only, 697
rename, 698
syntax, 699
modules
level-0, 700
most-negative-double-float, 701
most-negative-int, 702
most-positive-double-float, 703
most-positive-int, 704
multi-method, 705
multiple inheritance, 706, 707
<name>, 708
negative?, 712
new instance, 713
next-method?, 714
function signature, 715
normativeReferences, 716
null, 717
<null>, 718
null?, 719
number, 720
coercion, 721
module, 722
<number>, 723
number?, 724
Oaklisp, 725
object, 726
syntax, 727
syntax-1, 728
<object>, 729
object
syntax table, 730
objects, 731
ObjVLisp, 732
octal literals, 733
odd?, 734
only, 735
open-input-file, 736
open-output-file, 737
or, 738
rewrite rules, 739
syntax table, 740
pair, 741
pair, 742
pi, 743
positive?, 744
predicate, 747
primitive-allocate, 748
primitive-class-of, 749
primitive-ref, 750
prin-char, 751
print, 752
processing
constants, 753
symbols, 754
processor, 755
processor-defined
progn, 757
syntax table, 758
quasiquotation, 759
quasiquote, 760
syntax table, 762
quote, 763
syntax table, 765
range-condition, 766
read, 767
read-line, 768
reader, 769
reflective, 772
remove, 773
rename, 774
required?, 775
return-from, 776
rewrite rules, 777
syntax table, 779
reverse, 780
rewrite rules
and, 781
block, 782
catch, 783
cond, 784
defgeneric, 785
defun, 786
generic function, 787
let, 788
let*, 789
or, 790
return-from, 791
throw, 792
unless, 793
when, 794
scan, 797
scope, 798
scope and extent
of dynamic-let bindings, 800
self-instantiated class, 803
<sequence>, 804
sequence?, 805
setq, 806
syntax table, 807
setter, 808
setter function, 809
(setter car), 810
(setter cdr), 811
(setter converter), 812
(setter element), 813
(setter method-function), 814
(setter primitive-class-of), 815
(setter primitive-ref), 816
sflush, 817
sformat, 818
shallow-copy, 819, 820, 821, 822, 823, 824
signal, 825
signum, 826
simple function, 827
<simple-class>, 828
<simple-function>, 829
<simple-generic-function>, 830
<simple-method>, 831
<simple-thread>, 832
single inheritance, 835
size, 838
slice, 839
slot, 840
<slot>, 841
slot description, 842
slot option, 843
slot specification, 844
slot-default-function, 845
slot-name, 846
slot-slot-reader, 847
slot-slot-writer, 848
sort, 849
special operator, 852
special-0-forms
syntax table, 853
specialize, 854
specialize on, 855
sprin-char, 856
sprint, 857
sread, 860
standard module, 864
static error, 865
stderr, 866
stdin, 867
stdout, 868
stream, 869
module, 870
<stream>, 871
stream-buffer, 872
stream-buffer-size, 873
stream-lock, 874
stream-sink, 875
stream-source, 876
stream?, 877
string, 878
escaping in, 879
module, 880
string-escape glyph, 881
string, 884
syntax table, 885
<string-stream>, 886
string-stream?, 887
string?, 888
subclass, 889
direct, 890
indirect, 891
superclass, 892
direct, 893
swrite, 894
symbol, 895
module, 896
<symbol>, 897
syntax table, 901
symbol-exists?, 902
symbol-name, 903
symbol?, 904
generic function lambda-list, 907
syntax operator, 912, 913, 914
syntax-1, 916
t, 919
table, 920
module, 921
<table>, 922
table?, 923
telos0, 928
module, 929
thread, 930
module, 931
<thread>, 932
thread-reschedule, 933
thread-start, 934
thread-value, 935
thread?, 936
throw, 937
rewrite rules, 938
syntax table, 939
ticks-per-second, 940
to-stream, 941
top dynamic, 942
top lexical, 943
unless, 948
rewrite rules, 949
syntax table, 950
unlock, 951
unquote, 952
syntax table, 954
unquote-splicing, 955
syntax table, 956
unwind-protect, 957
syntax table, 958
vector, 959
module, 960
<vector>, 961
vector, 962
syntax table, 963
vector?, 964
violation, 965
when, 968
rewrite rules, 969
syntax table, 970
whitespace, 971
with-handler, 972
syntax table, 973
with-input-file, 974
syntax table, 975
with-output-file, 976
syntax table, 977
with-sink, 978
syntax table, 979
with-source, 980
syntax table, 981
write, 982
writer, 983
[next]