ToC

Preface:

Chapter 1: The Extensible Language

Chapter 2: Functions
Chapter 3: Functional Programming
Chapter 4: Utility Functions
Chapter 5: Returning Functions
Chapter 6: Functions As Representations
Chapter 7: Macros
Chapter 8: When To Use Macros
Chapter 9: Variable Capture
Chapter 10: Other Macro Pitfalls
Chapter 11: Classic Macros
Chapter 12: Generalized Variables
Chapter 13: Computation At Compile Time
Chapter 14: Anaphoric Macros
Chapter 15: Macros Returning Functions
Chapter 16: Macro Defining Macros
Chapter 17: Read Macros
Chapter 18: Destructuring
Chapter 19: A Query Compiler
Chapter 20: Continuations
Chapter 21: Multiple Processes
Chapter 22: Non Determinism
Chapter 23: Parsing With ATNs
Chapter 24: Prolog
Chapter 25: Object Oriented Lisp

Detailed ToC

Preface:

Chapter 1: The Extensible Language

1.1 Design By Evolution
1.2 Programming Bottom Up
1.3 Extensible Software
1.4 Extending Lisp
1.5 Why Lisp (Or When)

Chapter 2: Functions
1. Functions As Data
2. Defining Functions
3. Functional Arguments
4. Functions As Properties
5. Scope
6. Closures
7. Local Functions
8. Tail Recursion
9. Compilation
10. Functions From Lists

Chapter 3: Functional Programming

1. Functional Design
2. Imperative Outside In
3. Functional Interfaces
4. Interactive Programming
Chapter 4: Utility Functions
1. Birth Of An Utility
2. Invest In Abstraction
3. Operations On Lists
4. Search
5. Mapping
6. IO
7. Symbols And Strings
8. Density

Chapter 5:
1. Returining Functions
2. Common Lisp Evolves
3. Memoizing
4. Composing Functions
5. Recursion On Cdrs
6. Recursion On Subtrees
7. When To Build Functions

Chapter 6: Functions As Representations

1. Networks
2. Compiling Networks
3. Looking Forward

Chapter 7: Macros
1. How Macros Work
2. Backquote
3. Defining Simple Macros
4. Testing Macroexpansion
5. Destructuring As Parameter Lists
6. A Model Of Macros
7. Macros As Programs
8. Macro Style
9. Dependence On Macros
10. Macros From Functions
11. Symbol Macros

Chapter 8: When To Use Macros

1. When Nothing Else Will Do
2. Macro Or Function
3. Applications For Macros

Chapter 9: Variable Capture

1. Macro Argument Capture
2. Free Symbol Capture
3. When Capture Occurs
4. Avoiding Capture With Better Names
5. Avoiding Capture With Prior Evaluation
6. Avoiding Capture With Gensyms
7. Avoiding Capture With Packages
8. Capture In Other Namespaces
9. Why Bother

Chapter 10: Other Macro Pitfalls

1. Number Of Evaluations
2. Order Of Evaluation
3. Non Functional Expanders
4. Recursion
Chapter 11: Classic Macros
1. Creating Contexts
2. The with- macro
3. Conditional Evaluation
4. Iteration
5. Iteration With Multiple Values
6. Need For Macros

Chapter 12: Generalized Variables

1. The Concept
2. The Multiple Evaluation Problem
3. New Utilities
4. More Complex Utilities
5. Defining Inversions

Chapter 13: Computation At Compile Time

13.1 New Utilities
13.2 Example: Bezier Curves
13.3 Applications

Chapter 14: Anaphoric Macros

14.1 Anaphoric Variants
14.2 Failure
14.3 Referential Transparency

Chapter 15: Macros Returning Macros

15.1 Building Functions
15.2 Recursion On Cdrs
15.3 Recursion On Subtrees
15.4 Lazy Evaluation

Chapter 16: Macro Defining Macros

16.1 Abbreviations
16.2 Properties
16.3 Anaphoric Macros

Chapter 17: Read Macros

17.1 Macro Characters
17.2 Dispatching Macro Characters
17.3 Delimiters
17.4 When What Happens

Chapter 18: Destructuring

18.1 Destructuring On Lists
18.2 Other Structures
18.3 Reference
18.4 Matching

Chapter 19: A Query Compiler

19.1 The Database
19.2 Pattern Matching Queries
19.3 A Query Interpreter
19.4 Restrictions On Binding
19.5 A Query Compiler

Chapter 20: Continuations

20.1 Scheme Continuations
20.2 Continuation Passing Macros
 20.3 Code-Walkers and CPS Conversions

Chapter 21: Multiple Processes

21.1 The Process Abstraction
21.2 Implementation
21.3 The Less-Than-Rapid Prototype

Chapter 22: Non Determinisim

22.1 The Concept
22.2 Search
22.3 Scheme Implementation
22.4 Common Lisp Implementation
22.5 Cuts
22.6 True Non Determinism

Chapter 23: Parsing With ATNs

23.1 Background
23.2 The Formalism
23.3 Non Determinism
23.4 An ATN Compiler
23.5 A Sample ATN

Chapter 24: Prolog

24.1 Concepts
24.2 An Interpreter
24.3 Rules
24.4 The Need For Non Determinism
24.5 New Implementation
24.6 Adding Prolog Features
24.7 Examples
24.8 The Senses Of Compile

Chapter 25: Object Oriented Lisp

25.1 Plus ca change
25.2 Objects In Plain Lisp
25.3 Classes And Instances
25.4 Methods
25.5 Auxiliary Methods And Combination
25.6 CLOS and Lisp
25.7 When To Object