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-Velskii-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
- Eratosthenes 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
- Eratosthenes 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
- Eratosthenes 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
|