__________________________________________________________________________________________________

Programming Language EuLisp
Version 0.991
WORKING DRAFT
______________________________________________________________________________________________________________________________________________________________________

Contents
Foreword
Introduction
1 Language Structure
2 Scope
3 Normative References
4 Conformance Definitions
5 Error Definitions
6 Compliance
7 Conventions
8 Definitions
9 Lexical Syntax
10 Modules
11 Objects
12 Level-0 Defining, Special and Function-call Forms
13 Condition Classes
14 Condition Signalling and Handling
15 Concurrency
16 Level-0 Module Library
17 Programming Language EuLisp, Level-1
Bibliography
Module Index
Class Index
Special Forms Index
Function Index
Generic Function Index
Condition Index
Constant Index
Index

Foreword

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.

Programming Language EuLisp —
Version 0.991

Introduction

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].

Bibliography

[1]
Alberga, C.N., Bosman-Clark, C., Mikelsons, M., Van Deusen, M., & Padget, J.A., Experience with an Uncommon LISP, Proceedings of 1986 ACM Symposium on LISP and Functional Programming, ACM, New York, 1986 (also available as IBM Research Report RC-11888).
[2]
Berrington N., Deroure D. & Padget J.A., Guaranteeing Unpredictability, in preparation.
[3]
Bobrow D.G., DiMichiel L.G., Gabriel R.P., Keene S.E, Kiczales G. & Moon D.A, Common Lisp Object System Specification, SIGPLAN Notices, Vol. 23, September 1988.
[4]
Chailloux J., Devin M. & Hullot J-M., LELISP: A Portable and Efficient Lisp System, Proceedings of 1984 ACM Symposium on Lisp and Functional Programming, Austin, Texas, pp113-122, published by ACM Press, New York.
[5]
Chailloux J., Devin M., Dupont F., Hullot J-M., Serpette B., & Vuillemin J., Le-Lisp de l’INRIA, Version 15.2, Manuel de référence, INRIA, Rocquencourt, May 1987.
[6]
Clinger W. & Rees J.A. (eds.), The Revised3 Report on Scheme, SIGPLAN Notices, Vol. 21, No. 12, 1986.
[7]
Cointe P., Metaclasses are First Class: the ObjVlisp model, Proceedings of OOPSLA ’87, published as SIGPLAN Notices, Vol 22, No 12 pp156-167.
[8]
Fitch J.P. & Norman A.C., Implementing Lisp in a High-Level Language, Software Practice and Experience, Vol 7, pp713-725.
[9]
Friedman D. & Haynes C., Constraining Control, Proceedings of 11th Annual ACM Symposium on Principles of Programming Languages, pp245-254, published by ACM Press, New York, 1985.
[10]
Hudak P. & Wadler P., (eds.) Report on the Functional Programming Language Haskell, Yale University, Department of Computer Science, Research Report YALEU/DCS/RR-666, December 1988.
[11]
Landin P.J., The Next 700 Programming Languages, Communications of the ACM, Vol 9, No 3., 1966, pp156-166.
[12]
Lang K.J. & Pearlmutter B.A., Oaklisp: An Object-Oriented Dialect of Scheme, Lisp and Symbolic Computation, Vol. 1, No. 1, June 1988, pp39-51, published by Kluwer Academic Publishers, Boston.
[13]
MacQueen D., et al, Modules for Standard ML, Proceedings of 1984 ACM Symposium on Lisp and Functional Programming, Austin, Texas, pp198-207, published by ACM Press, New York.
[14]
Milner R., et al, Standard ML, Laboratory for the Foundations of Computer Science, University of Edinburgh, Technical Report.
[15]
Padget J.A., et al, Desiderata for the Standardisation of Lisp, Proceedings of 1986 ACM Conference on Lisp and Functional Programming, pp54-66, published by ACM Press, New York, 1986.
[16]
Pitman K.M., An Error System for Common Lisp, ISO WG16 paper N24.
[17]
Rees J.A., The T Manual, Yale University Technical Report, 1986.
[18]
Slade S., The T Programming Language, a Dialect of Lisp, Prentice-Hall 1987.
[19]
Shalit A., Dylan, an object-oriented dynamic language, Apple Computer Inc., 1992.
[20]
Steele G.L. Jr., Common Lisp the Language, Digital Press, 1984.
[21]
Steele G.L. Jr., Common Lisp the Language (second edition), Digital Press, 1990.
[22]
Stoyan H. et al, Towards a Lisp Standard, published in the Proceedings of the 1986 European Conference on Artificial Intelligence.
[23]
Teitelman W., The Interlisp Reference Manual, Xerox Palo Alto Research Center, 1978.
[24]
Bretthauer, H. and Kopp, J., The Meta-Class-System MCS. A Portable Object System for Common Lisp. -Documentation-. Arbeitspapiere der GMD 554, Gesellschaft fur Mathematik und Datenverarbeitung (GMD), Sankt Augustin (July 1991).

Module Index

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

Class Index

<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

Special Forms Index

(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

Function Index

* (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

Generic Function Index

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

Condition Index

<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

no-setter (level-0), 46, 47

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

Constant Index

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

Index

, 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-generic, 19, 20

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

acos, 31, 32

add-method, 33, 34

all?, 35

allocate, 36, 37, 38

and, 39

   rewrite rules, 40

   syntax table, 41

any?, 42

applicable method, 43

apply, 44

   syntax table, 45

apply-method, 46

as-lowercase, 47, 48, 49

as-uppercase, 50, 51, 52

asin, 53, 54

assignment, 55

atan, 56, 57

atan2, 58, 59

atom?, 60

backquoting, 61

base, 62

   arbitrary base literals, 63

   limitation on input, 64

binary literals, 65

binary*, 66, 67, 68

binary+, 69, 70, 71

binary-, 72, 73, 74

binary-gcd, 75, 76

binary-lcm, 77, 78

binary-mod, 79, 80, 81

binary/, 82, 83, 84

binary<, 85, 86, 87, 88, 89

binary=, 90, 91, 92, 93, 94, 95, 96, 97, 98

binary% , 99, 100

binding, 101

   dynamically scoped, 102

   module, 103

   of module names, 104, 105

   top dynamic, 106

block, 107

   rewrite rules, 108

   see also let/cc, 109

   syntax table, 110

boolean, 111, 112

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

ceiling, 126, 127

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

Common Lisp, 140, 141

class, 142, 143

   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

compliance, 179, 180

compute-and-ensure-slot-accessors, 181, 182

compute-class-precedence-list, 183, 184

compute-constructor, 185, 186

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-keywords, 197, 198

compute-method-lookup-function, 199, 200

compute-predicate, 201, 202

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-slot-reader, 211, 212

compute-slot-writer, 213, 214

compute-slots, 215, 216

compute-specialized-slot, 217, 218

compute-specialized-slot-class, 219, 220

concatenate, 221

concurrency, 222

cond, 223

   rewrite rules, 224

   syntax table, 225

condition, 226, 227

   continuable, 228

   module, 229

   non-continuable, 230

<condition>, 231

condition?, 232

configuration, 233

conformance, 234

   level-0, 235, 236

   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

constant, 269, 270

constructor, 271

continuation, 272, 273, 274

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

cos, 294, 295

cosh, 296, 297

current-thread, 298

deep-copy, 299, 300, 301, 302, 303, 304

default, 305

default, 306

default-function, 307

defclass, 308, 309

   syntax table, 310

defclass-1

   syntax table, 311

defcondition, 312

   syntax table, 313

defconstant, 314

   syntax table, 315

defgeneric, 316, 317, 318

   rewrite rules, 319

   syntax table, 320

defgeneric-1

   syntax table, 321

defglobal, 322

   syntax table, 323

defining form, 324, 325

defining operator, 326

defining-0-forms

   syntax table, 327

deflocal, 328

   syntax table, 329

defmethod, 330, 331

   syntax table, 332

defmethod-1

   syntax table, 333

defmodule, 334, 335

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

disconnect, 347, 348, 349

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

end-of-stream, 370, 371, 372

ensure-slot-reader, 373, 374

ensure-slot-writer, 375, 376

environmental error, 377

eq, 378

   implementation-defined behaviour, 379

eql, 380

error, 381, 382

   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

even?, 394, 395

except, 396

exit-1, 397

   module, 398

exp, 399, 400

export, 401, 402

expose, 403, 404

extension, 405

extent, 406

external representation

   floating point, 407

   integer, 408, 409

   list, 410

   null (empty list), 411

   pair, 412

   string, 413

   vector, 414

external representation (see also ?? and write), 415

false, 416, 417

<file-stream>, 418

file-stream-buffer-position, 419

file-stream-filename, 420

file-stream-mode, 421

file-stream?, 422

fill, 423

fill-buffer, 424, 425, 426

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

floor, 437, 438

flush, 439

flush-buffer, 440, 441, 442

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

generic-lambda, 479, 480, 481

   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

Haskell, 512, 513

hexadecimal literals, 514

identifier, 515, 516

   definition of, 517

   peculiar identifiers, 518

identifier

   syntax table, 519

identifiers, 520

if, 521

   syntax table, 522

implementation-defined, 523

   behaviour of eq, 524

   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

import, 536, 537

indefinite extent, 538

indirect instance, 539

indirect subclass, 540

inheritance

   multiple, 541, 542

   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

InterLISP, 568, 569

key-sequence, 570

keyword, 571, 572, 573

   abstract?, 574

   accessor, 575

   class, 576

   constructor, 577

   default, 578

   definition of, 579

   except, 580

   export, 581, 582

   expose, 583, 584

   import, 585, 586

   keyword, 587

   keywords, 588

   method, 589

   module, 590

   only, 591

   predicate, 592

   reader, 593

   rename, 594

   required?, 595

   syntax, 596, 597

   writer, 598

<keyword>, 599

keyword, 600, 601

   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

LE-LISP, 615, 616

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

level-0, 628, 629

lexical environment, 630

lexical scope, 631

lexical syntax, 632

lispin, 633

LISP/VM, 634, 635

list, 636, 637

   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

log, 656, 657

log10, 658, 659

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

module, 687, 688

   directives, 689

   environments, 690

   except, 691

   export, 692

   expose, 693

   import, 694

   name bindings, 695, 696

   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

negate, 709, 710, 711

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

pow, 745, 746

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

   gensym names, 756

progn, 757

   syntax table, 758

quasiquotation, 759

quasiquote, 760

   abbreviation with , 761

   syntax table, 762

quote, 763

   abbreviation with , 764

   syntax table, 765

range-condition, 766

read, 767

read-line, 768

reader, 769

reconnect, 770, 771

reflective, 772

remove, 773

rename, 774

required?, 775

return-from, 776

   rewrite rules, 777

   see also let/cc, 778

   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

round, 795, 796

scan, 797

scope, 798

scope and extent

   in letfuns expressions, 799

   of dynamic-let bindings, 800

   of lambda bindings, 801

   of let/cc binding, 802

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

sin, 833, 834

single inheritance, 835

sinh, 836, 837

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 form, 850, 851

special operator, 852

special-0-forms

   syntax table, 853

specialize, 854

specialize on, 855

sprin-char, 856

sprint, 857

sqrt, 858, 859

sread, 860

Standard ML, 861, 862, 863

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>, 882, 883

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

symbol, 898, 899, 900

   syntax table, 901

symbol-exists?, 902

symbol-name, 903

symbol?, 904

syntax, 905, 906

   generic function lambda-list, 907

syntax, 908, 909

syntax expansion, 910, 911

syntax operator, 912, 913, 914

   definition by defsyntax, 915

syntax-1, 916

T, 917, 918

t, 919

table, 920

   module, 921

<table>, 922

table?, 923

tan, 924, 925

tanh, 926, 927

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

true, 944, 945

truncate, 946, 947

unless, 948

   rewrite rules, 949

   syntax table, 950

unlock, 951

unquote, 952

   abbreviation with ,, 953

   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

wait, 966, 967

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

zero?, 984, 985, 986

[next]