Table of Contents


Index

Symbols

% (percent sign), Prolog comments, 168
(-) dashes, using in Prolog predicates/clauses, 220

A

Abrahams, Paul, 3
accessing slots (CLOS), 117-119, 123-125
Accumulator parameter, Prolog predicates, 217
adding
data types to Guile, 96-98
functions to Guile, 94-96
after methods (CLOS), 119-120, 132-134, 142
algorithms (Prolog), 178
anonymous variables (Prolog), 214-215
append predicate (Prolog), 176
applicable methods (CLOS), 130
arguments
CLOS (Common Lisp Object System)
dispatching multiple, 117
methods, 129-130
DCGs (Prolog), 204
passing to Emacs Lisp functions, 28
Prolog predicates, 169
arithmetic operators (Prolog), 188-189
around method (CLOS), 132-134
Art of the Metaobject Protocol, The, 138
assert predicate (Prolog), 206-207, 214
atoms (Lisp lists), 8, 172
auto-saving Emacs Lisp, 51
auxiliary
methods (CLOS), 120, 129-132
predicates (Prolog), 218
AVL (Adelson-Velski’i-Landis) tree, 220

B

backquotes (` ), Emacs Lisp macros, 43
backups (Emacs Lisp), 51
Bagof predicate (Prolog), 197-198
before method (CLOS), 120, 132-134
binary infix predicates (Prolog), 189
Blandy, Jim, 87
breakpoints (Prolog debugger), setting, 201-202
buffer-local variables (Emacs Lisp), 26, 29-31
built-in functions (Emacs Lisp), 22
Byrd box debugger (Prolog), 198-202
byte compilation (Emacs Lisp), 52
byte-code interpreter (GNU Emacs), 7

C

C (programming language)
coexistence with Scheme, 98-100
interaction
with Guile, 90, 96
with Scheme, 94
programs, checking memory leaks, 224
C++, member functions, 116
C-Prolog, 163
call events, Prolog predicates, 199
call-with-current-continuation (Scheme), 71
car function (Emacs Lisp), 37
cdr function (Emacs Lisp), 37
characters (Prolog)
symbol characters, 209
valid operator declarations, 209-210
classes
CLOS (Common Lisp Object System), 111-112
metaclasses, 121
characteristics of, 122
defining, 111
direct superclasses, 113
inheritance, 112, 114, 127-128
instances, 120, 135, 137, 140
linearization, 128
metaclasses, 138-139
mix-in classes, 113, 125-127
multiple inheritance, 113
redefining, 134-137
renaming, 154
returning names of, 151
subclasses, 112
superclasses, 112
functionality of in OOP, 109
Smalltalk
inheritance, 113
instances, 112
clauses (Prolog), 169, 172
complex, 177-178
first argument indexing, 218-219
matching predicates to, 182
reading from the terminal, 219
tail recursion optimization, 217
transitive closure, 216-217
using dashes in, 220
CLOS (Common Lisp Object System), 108
arguments, dispatching multiple, 117
benefits to Lisp programs, 110
classes, 111-112
characteristics of, 122
defining, 111
direct superclasses, 113
inheritance, 112, 114, 127-128
instances, 120, 135, 137, 140
linearization, 128
metaclasses, 121, 138-139
mix-in classes, 113, 125-127
multiple inheritance, 113
redefining, 134-137
renaming, 154
returning names of, 151
subclasses, 112
superclasses, 112
dependency tracking, 138
applied to immediate update, 139-143
applied to lazy evaluation, 144-148
dynamic features of, 109
extending with MOP, 137-148
function specification, 118, 141
generic functions, 114-116, 129-132
defining, 152
resolution, 115
keywords, 111
macros
with-accessors, 123-125
with-slots, 123-125
methods, 114
after, 142
after methods, 119-120
applicable, 130
arguments, 129-130
auxiliary methods, 120, 129-134
before methods, 120
customizing, 115
defaults, 130
defining, 154
finding next, 155
multimethods, 115
object specialization, 131
operator method combination, 134
order of precedence, 131
overriding, 116
parameter list, 132
primary methods, 119, 129-132
ranking by specificity, 131
returning values of, 150
standard method combination, 120, 132
modular code, 125-127
MOP, 120-122
notation, 150
objects, 109
interface, 109
outputting descriptions of, 154
returning for methods, 155
returning names of, 151
OOP functionality, 109
operators, 150-157
origin of, 108
overriding, 120
performance considerations, 149
program design, 109
slots
accessing, 117-119, 123-125
customizing behavior of, 121
defining, 111
immediate updates, 144
inheritance characteristics, 128-129
initializing, 155
local, 112, 123
named, 111
options, 111
recalculating based on dependency changes, 146
recursion, 147
returning values of, 156
setting values for, 118
shared, 112, 123
updating during class redefinition, 135-136
updating instance redefinition, 137
using names as variables, 157
Colmerauer, Alain, 162
commands
Emacs Lisp, 22
find-tag, 13
M-x load-file, 51
Prolog debugger, 200 see also functions
comments
Emacs Lisp, 12
Prolog, 168, 212-213
Common Lisp, 6, 120
Common Lisp Object System, 108
Common Objects, 108
CommonLoops, 108
compilers, Prolog, 163
computations (Prolog), changing global states of, 206
conditional special forms, Emacs Lisp, 31-32
cons function (Emacs Lisp), 37
constants (Prolog), 168-169, 172, 191
constructors (Scheme), troubleshooting, 84
continuation passing style, 69
converting Prolog interpreters to command interpreters, 208
Conway, John Horton, 226
CPS (continuation passing style), Scheme, 69, 71, 74
customizing
Guile, 94
methods in CLOS, 115
cut literal (Prolog), 186-187

D

dashes (-), using in Prolog predicates/clauses, 220
data types, 111
Guile, adding, 96-98
Prolog, lack of, 165
Scheme, 61-62
DCGs (Definite Clause Grammars), Prolog
arguments, 204
Prolog, 202, 205-206
rules, 203
writing, 202-203
debuggers
GNU Emacs, 5
Prolog, 198-202
breakpoints, 201-202
commands, 200-201
see also debugging
debugging
Emacs Lisp, 48-51
programs in Prolog, 183, 198-202
declaring operators (Prolog), 209, 211
defconst special form (Emacs Lisp), 26
defining
classes (CLOS), 111
Emacs Lisp functions, 11-12
functions
generic (CLOS), 152
Prolog, 165
global variables
conditionally, 26
unconditionally, 26
macros (Emacs Lisp), 41-42
methods (CLOS), 154
predicates (Prolog), 169, 184
slots (CLOS), 111
Definite Clause Grammars, 202
defmacro function (Emacs Lisp), 41-42
defun special form (Emacs Lisp), 11
defvar special form (Emacs Lisp), 26
delete predicate (Prolog), 186
dependency tracking (CLOS), 138
applied to immediate update, 139-143
applied to lazy evaluation, 144-148
direct superclasses (CLOS), 113
domain-specific languages, 90-93
dynamic predicate (Prolog), 207-208

E

Edebug (Emacs Lisp debugger), 49-50
editing Emacs Lisp, 7, 46
Edwards, Daniel, 3
Emacs Lisp, 5
.emacs initialization file, 52-53
antecedents, 5
auto-saving, 51
backup files, 51
byte compilation, 52
characteristics of, 5
commands, 22
find-tag, 13
M-x load-file, 51
comments, 12
debugging, 48-51
documentation on, 6
editing, 46
editing terminology, 7
expressions
and, 33-36
evaluating repeatedly, 36
evaluating sequentially, 31
let, 28-29
not, 33-36
or, 33-36
fill-prefixes, 33
functions, 9, 22
macroexpand, 42
quote, 9
built-in, 22
car, 37
cdr, 37
cons, 37
defining, 11-12
defmacro, 41-42
documentation, 12
evaluating, 12
finding source for, 13
forward-line, 15
interactive, 12, 16-17
lambda, 20
list, 42-43
non-interactive, 14
passing arguments to, 28
recursive, 40
save-excursion, 14
setq, 18, 27
Help, 47
keymaps, 44-46
lists, 8
atoms, 8
components, 8
evaluating, 10
nested, 8
running, 9
loading whole file, 51
macros, 22
backquoted lists, 43
defining, 41-42
Mark, 14
mechanics of, 10
point, 12
running in batch mode, 7
side effects, 22-25
source, accessing, 47
special forms, 10
conditional, 31-32
defconst, 26
defun, 11
defvar, 26
progn, 31
while, 36-40
symbols
components, 18
evaluating, 18-19, 21
property lists, 44
variables, 17-18, 25
buffer-local variables, 29-31
global, 26-27
setting, 27
setting with let expression, 28-29
values, 17-18
empty lists
Emacs Lisp, 8
Prolog, 174
encapsulation, CLOS slots, 117-119
equality (Prolog)
goals, 173
predicates, 172
properties, 173
variables, 173
Eratosthene’s sieve, Prolog program, 224
evaluating
Emacs Lisp
expressions, 31, 36
files, 51
functions, 12
lists, 9-10
symbols, 18-19, 21
expressions with Lisp interpreter, 10
events, Prolog predicates, 199
execution model (Prolog), 178-183
exit events (Prolog predicates), 199
expressions
Emacs Lisp
and, 33-36
let, 28-29
not, 33-36
or, 33-36
evaluating, 10, 31, 36
Scheme, 59, 84
extending CLOS, 137-148

F

facts (Prolog), 169, 172
asserting, 206
retracting, 207
fail
events, Prolog predicates, 199
operator (Prolog), 195
fill-prefixes, Emacs Lisp, 33
find-tag command (Emacs Lisp), 13
findall predicate (Prolog), 196-197
finding text file nodes, 13-15
first argument indexing, Prolog clauses, 218-219
first-class data (Scheme), 65-67
flow control (Prolog), 195-196
forms, 9
forward-line function (Emacs Lisp), 15
four-port debugger, Prolog, 198-202
Free Software Foundation, Inc., 6
functions, 176
C++, member, 116
CLOS
generic functions, 129-132
specification, 118, 141
Emacs Lisp, 9, 22
macroexpand, 42
quote, 9
built-in, 22
car, 37
cdr, 37
cons, 37
defining, 11-12
defmacro, 41-42
documentation, 12
evaluating, 12
finding source for, 13
forward-line, 15
interactive, 12, 16-17
lambda, 20
list, 42-43
non-interactive, 14
passing arguments to, 28
recursive, 40
save-excursion, 14
setq, 18, 27
generic functions (CLOS), 114-116
Guile, adding, 94-96
libraries, 26
Prolog
defining, 165
solve clause(), 179
solve eq(), 180
symbols, 190-191, 209
Scheme, programming, 77-79
see also commands

G

Game of Life, Prolog program, 226
genealogy program (Prolog), 167-172
generic functions, CLOS, 114-116, 129-132
defining, 152
resolution, 115
global variables, Emacs Lisp, 25-27
GNU Emacs
distribution, 5
characteristics of, 6
debuggers, 5
interpreters, 7
GNU Emacs, 5
goals, Prolog, 172
calling within DCG clauses, 205
equality goals, 173
solving all, 196-198
Goedel, 163
grammars, 202
Guile (Scheme interpreter), 87, 93
application design tips, 100-101
availability, 103
coexistence with C, 98-100
customizing, 94
data types, adding, 96-98
functions, adding, 94-96
goal of, 90
interaction
transcript, 88-89
with C, 90, 96
SCWM, 91
library, 89-90
online resources, 103
script interpreter capabilities, 89
Smobs, 96-98
translators, 88
versus other interpreters, 103

H

Hart, Timothy, 3
Harvey, Brian, 57
Hello World program (Prolog), 166-167
help (Emacs Lisp), 47
Hewitt, Carl, 107
hygienic macros (Scheme), 76-77

I-J

I/O (Prolog)
predicates, 192
source files, 195
streams, 195
terms, 192
identifiers (Prolog), 172
if special form (Emacs Lisp), 31-32
if-then-else operator (Prolog), 195
infinite terms (Prolog), 216
inheritance
CLOS classes, 112, 114
multiple inheritance, 125
order of precedence, 127-128
slots, 128-129
Smalltalk classes, 113
variables (Scheme), 64-65
initializing slots (CLOS), 155
instances
CLOS classes, 111-112, 120, 140
changing, 135, 137, 150
reinitializing after updates, 156-157
returning, 155
Smalltalk classes, 112
instantiation, Prolog variables, 182, 197
interactive function (Emacs Lisp), 12, 16-17
interfaces (CLOS objects), 109
interpreters
GNU Emacs, 7
Guile, 87-88
Lisp
Prolog program, 229
Prolog-based, 164
Prolog, 164, 208
Python, 103
Tcl, 103
is predicate (Prolog), 189

K

KEE, 108
keymaps (Emacs Lisp), 44-46
keys (Prolog), associating with values, 220
keywords (CLOS), 111
knowledge bases, Prolog, 169
Kowalski, Robert, 162
KRL (Knowledge Representation Language), 108

L

Lambda functions (Emacs Lisp), 20
let expressions (Emacs Lisp), 28-29
Levin, Michael, 3
lexical scope (Scheme), 64-65, 74-77
libraries
functions, 26
Guile, 89-90
linearization, CLOS classes, 128
LISP, 3, 5, 107-108
Common Lisp, 120
data, 3
dialects, 108
interpreters
GNU Emacs, 7
Prolog program, 229
Prolog-based, 164
M-expressions, 3
meta-language, 3
MOP (Metaobject Protocol), 108
Object Lisp, 108
objects, 122
OOP, 108
predicate, 35
programs
CLOS benefits, 110
interpretation/execution, 4
S-expressions, 3, 9
standards, 108
versus other programming languages, 3
Lisp Interaction Mode (Emacs lisp editing), 47
list function (Emacs Lisp), 42-43
lists
Emacs Lisp, 8
components, 8
evaluating, 10
running, 9
Prolog, 174-175
appending, 176
querying, 174
recursive predicates, 175-176
versus function symbols, 190-191
literals, cut (Prolog), 184, 186-187
loading whole Emacs Lisp files, 51
local
slots (CLOS), 112, 123
variables
Emacs Lisp, 25
Prolog, 171
loops, while (Emacs Lisp), 36-39

M

M-expressions, 3
M-x load-file command (Emacs Lisp), 51
MacLisp, 5
macroexpand function (Emacs Lisp), 42
macros
CLOS
with-accessors, 123-125
with-slots, 123-125
Emacs Lisp, 22
backquoted lists, 43
defining, 41-42
lexical scoping rules, 74-77
Scheme, hygienic, 76-77
McCarthy, John, 3, 107, 162
member
functions, C++, 116
predicate, Prolog, 176
mercury, 163
meta-language, 3
metaclasses (CLOS), 121, 138-139
Metaobject Protocol, 108
methods (CLOS), 114
after, 142
after methods, 119-120
applicable, 130
arguments, 129-130
auxiliary methods, 120, 129-134
before methods, 120
customizing, 115
defaults, 130
defining, 154
finding next, 155
multimethods, 115
object specialization, 131
operator method combination, 134
order of precedence, 131
overriding, 116
parameter list, 132
primary methods, 119, 129-132
ranking by specificity, 131
returning values of, 150
standard method combination, 120, 132
Minsky, Marvin, 162
mix-in classes (CLOS), 113, 125-127
modules (CLOS), 125-127
MOP (Metaobject Protocol), 120-122
Lisp, 108
efficiency of, 122
extending CLOS, 137-148
multi-arity predicates, Prolog, 188
multimethods (CLOS), 115
multiple argument dispatch
C++, 117
CLOS (Common List Object System), 117
multiple inheritance (CLOS), 113, 125

N

name predicate (Prolog), 191
named slots (CLOS), 111
naming
constants (Prolog), 169
predicates (Prolog), 169, 172, 212-213
neats (Artificial Intelligence programming), 162
negations, Prolog, 184
computing, 184
logical soundness of, 185-186
nested lists (Emacs Lisp), 8
new flavors, 108
nil, empty lists, 9
Nl predicate (Prolog), 183
nodes, finding text files, 13-15
non-interactive functions (Emacs Lisp), 14
notation
CLOS (Common List Object System), 150
programs, 90
Prolog, 165, 174
numeric terms (Prolog), 188

O

Object Lisp, 108
objects
CLOS (Common List Object System), 109
interface, 109
outputting descriptions of, 154
returning for methods, 155
returning names of, 151
functionality of in OOP, 109
Lisp, 122
occurs checks (Prolog), 216
OOP (Object-oriented programming), 109
CLOS functionality, 109
Lisp, 108
Scheme, 80-81
operator method combination (CLOS), 134
operators
CLOS (Common List Object System), 150-157
Prolog
arithmetic operators, 188-189
character sequences, 209-210
declaring, 209
fail, 195
grouping operands, 210
if-then-else, 195
order of precedence, 210-211
specifiers, 210-211
true, 195
unary operators, 211
or () operator (Prolog), 195
overriding CLOS, 116, 120

P-Q

Paradigms of AI Programming, 149
parameters, Prolog predicates, 167
passing arguments to Emacs Lisp functions, 28
percent sign (%), Prolog comments, 168
persistent data (Prolog), recording, 208
plists, Emacs Lisp symbols, 44
point (Emacs Lisp), 12
predicates (Prolog), 167
accumulator parameter, 217
append, 176
arguments, 169
assert, 206-207, 214
auxiliary predicates, 218
bagof, 197-198
binary infix predicates, 189
comments in, 212-213
defining, 169, 184
delete, 186
dynamic, 207-208
equality predicates, 172-173
events, 199
findall, 196-197
hierarchy, 213-214
I/O predicates, 192
is, 189
matching to clauses, 182
member, 176
multi-arity predicates, 188
name, 191
naming, 169, 172, 212-213
negating, 186
nl, 183
parameters, 167
read, 192
recursion, 171-172, 175-176
retract, 206-207, 214
setof, 197-198
tell, 195
telling, 195
told, 195
using dashes in, 220
whitespace in, 212-213
write, 183, 192
prefix notation (Scheme), 60
primary methods (CLOS), 119, 129-132
printing (Scheme), troubleshooting, 83
processing
queries in Prolog, 182
S-expressions, 3
progn special form (Emacs Lisp), 31
programming languages, domain-specific, 90-93
programs
C, memory leaks, checking, 224
CLOS (Common List Object System), design, 109
Lisp, CLOS benefits, 110
notation, 90
Prolog, 172
AVL tree, 220
C memory leak checker, 224
debugging, 183, 198-202
design recommendations, 212-214
Eratosthene’s sieve, 224
Game of Life, 226
Genealogy, 167-172
Hello World, 166-167
Lisp interpreter, 229
querying for solutions, 169-170
storage, 167
Prolog
add-ons, 163
atoms, 172
backtracking search strategy, 164
C-Prolog, 163
characters, symbol characters, 209
clauses, 169, 172
complex, 177-178
first argument indexing, 218-219
reading from the terminal, 219
tail recursion optimization, 217
transitive closure, 216-217
using dashes in, 220
comments, 168, 212-213
compilers, 163
computations, changing global states of, 206
constants, 168-169, 172, 191
constraint processing, 163
data types, lack of, 165
DCGs, 202
arguments, 204
rules, 203
two-level parsing, 205-206
writing, 202-203
debugger, 198-202
breakpoints, 201-202
commands, 200-201
development, 163-164
development of, 162
dialects, 163
execution model, 161, 178-183
facts, 169, 172
asserting, 206
retracting, 207
flow control, 195-196
function symbols, 190-191, 209
functionality of, 161
functions
defining, 165
solve clause(), 179
solve eq(), 180
goals, 172
calling within DCG clauses, 205
equality goals, 173
solving all, 196-198
identifiers, 172
interpreters, 164, 208
keys, associating with values, 220
knowledge bases, 169
lists, 174-175
appending, 176
querying, 174
recursive predicates, 175-176
versus function symbols, 190-191
literals, 184, 186-187
negations
computing, 184
logical soundness of, 185-186
North American popularity, 162
notation, 165
occurs checks, 216
operators
arithmetic operators, 188-189
character sequences, 209-210
declaring, 209
fail, 195
grouping operands, 210
if-then-else, 195
order of precedence, 210-211
specifiers, 210-211
true, 195
unary operators, 211
origins of, 161
persistent data, recording, 208
practical applicability of, 163
predicates, 167
accumulator parameter, 217
append, 176
arguments, 169
assert, 206-207, 214
auxiliary predicates, 218
bagof, 197-198
binary infix predicates, 189
defining, 169, 184
delete, 186
dynamic, 207-208
equality predicates, 172-173
events, 199
findall, 196-197
hierarchy, 213-214
I/O predicates, 192
is, 189
matching to clauses, 182
member, 176
multi-arity predicates, 188
name, 191
naming, 169, 172
negating, 186
Nl, 183
parameters, 167
read, 192
recursion, 171-172, 175-176
retract, 206-207, 214
setof, 197-198
tell, 195
telling, 195
told, 195
using dashes in, 220
write, 183, 192
programs, 172
AVL tree, 220
C memory leak checker, 224
debugging, 183, 198-202
design recommendations, 212-214
Eratosthene’s sieve, 224
Game of Life, 226
Genealogy, 167-172
Hello World, 166-167
Lisp interpreter, 229
querying, 169-170
storage, 167
progress of, 163-164
queries, 166, 169-170, 172, 182
query prompts, 166
release of, 162
resources (text and online), 165
rules, 167, 170-172
asserting, 206
retracting, 207
solutions prompt, 170
source files, 167, 195
speed performance, 164
standards, 164
streams, I/O, 195
strings, 191-192
syntax, uniformity of, 212
terms, 172, 211-212
I/O, 192
infinite terms, 216
numeric, 188
unification, 182
Turbo Prolog, 163
variables, 172
anonymous variables, 214-215
instantiation, 182, 197
local, 171
singleton variables, 175, 214-215
value substitution, 182
versus other programming languages, 161
properties
lists, Emacs Lisp symbols, 44
Prolog equality predicates, 173
windows, toggling, 92
put(X) predicate (Prolog), 193
Python, 103-104
queries (Prolog), 166, 169-170, 172, 174, 182
quote function (Emacs Lisp), 9
quotes (’), Lisp lists, 9

R

read predicate (Prolog), 192
reading Prolog clauses from terminal, 219
recording persistent data in Prolog, 208
recursion
CLOS slots, 147
Emacs Lisp, 40
Prolog, 171-172, 175-176
Scheme, troubleshooting, 84
redefining CLOS classes, 134-137
Redo events
Prolog predicates, 199
renaming classes (CLOS), 154
resolution, CLOS generic functions, 115
retract predicate
Prolog, 206-207
overusing, 214
rules, Prolog, 167, 170-172
asserting, 206
DCGs, 203
retracting, 207
running
Emacs Lisp in batch mode, 7
lists in Emacs Lisp, 9

S

S-expressions, 3, 9
processing, 3
recursive functions, 3
save-excursion function (Emacs Lisp), 14
Scheme, 87
call-with-current- continuation, 71
characteristics of, 57
coexistence with C, 98-100
constructors, troubleshooting, 84
continuation passing style, 69, 71, 74
data types, 61-62
expressions, 59, 84
first-class data, 65-67
functional programming, 77-79
interaction with C, 94
interaction with SCWM, 92
internal definitions, 63-64
lexical scope, 64-65
Lisp relationship, 59
macros, hygienic, 76-77
memory allocation management, 60
OOP, 80-81
prefix notation, 60
printing, troubleshooting, 83
recursion, troubleshooting, 84
relationship to Algol, 63
syntax, troubleshooting, 81-82
syntax construction, 60
tail call elimination, 68
users, 58
variables, 62-63
inheritance, 64-65
troubleshooting, 83
scruffies (Artificial Intelligence programming), 162
SCWM (scheme window manager), 88, 91, 93
interaction with Guile, 91
interaction with Scheme, 92
online resources, 103
origin of, 93
procedure efficiency, 92
robustness, 93
seeing (X) predicate (Prolog), 194
setof predicate (Prolog), 197-198
setq function (Emacs Lisp), 18, 27
setting
Emacs Lisp variables, 27-29
keymaps (Emacs Lisp), 45
shared slots (CLOS), 112, 123
singleton variables (Prolog), 175, 214-215
slots (CLOS)
accessing, 117-119, 123-125
customizing behavior of, 121
defining, 111
immediate updates, 144
inheritance characteristics, 128-129
initializing, 155
local, 112, 123
named, 111
options, 111
recalculating based on dependency changes, 146
recursion, 147
returning values of, 156
setting values for, 118
shared, 112, 123
updating
during class redefinition, 135-136
during instance redefinition, 137
using names as variables, 157
Smalltalk, classes
inheritance, 113
instances, 112
smobs (Guile), 96-98
solutions prompt (Prolog), 170
solve clause() function (Prolog), 179
solve eq () function (Prolog), 180
solve (G) function (Prolog), 179
source files (Prolog), 167, 195
special forms (Emacs Lisp), 10
conditional, 31-32
defconst, 26
defun, 11
defvar, 26
progn, 31
while, 36-40
Stallman, Richard, 6
standard method combination (CLOS), 120, 132
standards
Lisp, 108
Prolog, 164
streams (Prolog), I/O, 195
strings (Prolog), 191-192
subclasses (CLOS), 112
superclasses (CLOS), 112
symbols
Prolog, 209
Emacs Lisp
components, 18
evaluating, 18-19, 21
property lists, 44
syntax
Prolog, uniformity of, 212
Scheme, 60, 81-82

T

tail call elimination (Scheme), 68
tail recursion optimization, Prolog clauses, 217
Tcl, 103-104
tell predicate (Prolog), 195
terms (Prolog), 172, 211-212
I/O, 192
infinite terms, 216
numeric, 188
unification, 182
Texinfo markup language, 13
texnfo-upd.el files, 13
txt files, finding nodes, 13-15
toggling window properties, 92
told predicate (Prolog), 195
transitive closure, Prolog clauses, 216-217
troubleshooting
Scheme
constructors, 84
expressions, 84
printing, 83
recursion, 84
syntax, 81-82
variables, 83
Prolog
true operator, 195
Turbo Prolog, 163

U

unary operators (Prolog), 211
unification (Prolog), 182
untyped variables (Scheme), 62-63

V

values, Emacs Lisp variables, 17-19
variables (Emacs Lisp), 17-18, 25-29
buffer-local variables, 29-31
global, 26-27
Prolog, 172
anonymous variables, 214-215
equality predicates, 173
instantiation, 182, 197
local, 171
singleton variables, 175, 214-215
value substitution, 182
Scheme, 62-63
inheritance, 64-65
troubleshooting, 83
Veitch, Jim, 107

W

while special form (Emacs Lisp), 36-40
whitespace
Emacs Lisp lists, 8
Prolog predicates, 212-213
windows
manipulating with SCWM, 91
properties, toggling, 92
with-accessors macro (CLOS), 123-125
with-slots macro (CLOS), 123-125
write predicate (Prolog), 183, 192
writing DCGs (Prolog), 202-203

X-Y-Z

XSB Prolog, 43, 163


Table of Contents