[Top] [Contents] [Index] [Page Top / Bottom]

Onlisp

download this manual file.

Preface   
1. The Extensible Language   
2. Functions   
3. Functional Programming   
4. Utility Functions   
5. Returning Functions   
6. Functions as Representation   
7. Macros   
8. When to Use Macros   
9. Variable Capture   
10. Other Macro Pitfalls   
11. Classic Macros   
12. Generalized Variables   
13. Computation at Compile-Time   
14. Anaphoric Macros   
15. Macros Returning Functions   
16. Macro-Defining Macros   
17. Read-Macros   
18. Destructuring   
19. A Query Compiler   
20. Continuations   
21. Multiple Processes   
22. Nondeterminism   
23. Parsing with ATNs   
24. Prolog   
25. Object-Oriented Lisp   
A. Packages   
B. Notes   
Index of Figures   
Index of Functions   
Concept Index   

 -- The Detailed Node Listing ---

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)   

Functions

2.1 Functions as Data   
2.2 Defining Functions   
2.3 Functional Arguments   
2.4 Functions as Properties   
2.5 Scope   
2.6 Closures   
2.7 Local Functions   
2.8 Tail-Recursion   
2.9 Compilation   
2.10 Functions from Lists   

Functional Programming

3.1 Functional Design   
3.2 Imperative Outside-In   
3.3 Functional Interfaces   
3.4 Interactive Programming   

Utility Functions

4.1 Birth of a Utility   
4.2 Invest in Abstraction   
4.3 Operations on Lists   
4.4 Search   
4.5 Mapping   
4.6 I/O   
4.7 Symbols and Strings   
4.8 Density   

Returning Functions

5.1 Common Lisp Evolves   
5.2 Orthogonality   
5.3 Memoizing   
5.4 Composing Functions   
5.5 Recursion on Cdrs   
5.6 Recursion on Subtrees   
5.7 When to Build Functions   

Functions as Representation

6.1 Networks   
6.2 Compiling Networks   
6.3 Looking Forward   

Macros

7.1 How Macros Work   
7.2 Backquote   
7.3 Defining Simple Macros   
7.4 Testing Macroexpansion   
7.5 Destructuring in Parameter Lists   
7.6 A Model of Macros   
7.7 Macros as Programs   
7.8 Macro Style   
7.9 Dependence on Macros   
7.10 Macros from Functions   
7.11 Symbol Macros   

When to Use Macros

8.1 When Nothing Else Will Do   
8.2 Macro or Function?   
8.3 Applications for Macros   

Variable Capture

9.1 Macro Argument Capture   
9.2 Free Symbol Capture   
9.3 When Capture Occurs   
9.4 Avoiding Capture with Better Names   
9.5 Avoiding Capture by Prior Evaluation   
9.6 Avoiding Capture with Gensyms   
9.7 Avoiding Capture with Packages   
9.8 Capture in Other Name-Spaces   
9.9 Why Bother?   

Other Macro Pitfalls

10.1 Number of Evaluations   
10.2 Order of Evaluation   
10.3 Non-functional Expanders   
10.4 Recursion   

Classic Macros

11.1 Creating Context   
11.2 The with- Macro   
11.3 Conditional Evaluation   
11.4 Iteration   
11.5 Iteration with Multiple Values   
11.6 Need for Macros   

Generalized Variables

12.1 The Concept   
12.2 The Multiple Evaluation Problem   
12.3 New Utilities   
12.4 More Complex Utilities   
12.5 Defining Inversions   

Computation at Compile-Time

13.1 New Utilities   
13.2 Bezier Curves Example   
13.3 Applications   

Anaphoric Macros

14.1 Anaphoric Variants   
14.2 Failure   
14.3 Referential Transparency   

Macros Returning Functions

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

Macro-Defining Macros

16.1 Abbreviations   
16.2 Properties   
16.3 Anaphoric Macros   

Read-Macros

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

Destructuring

18.1 Destructuring on Lists   
18.2 Other Structures   

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   

Continuations

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

Multiple Processes

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

Nondeterminism

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

Parsing with ATNs

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

Prolog

24.1 Concepts   
24.2 An Interpreter   
24.3 Rules   
24.4 The Need for Nondeterminism   
24.5 New Implementation   
24.6 Adding Prolog Features   
24.7 Examples   
24.8 The Senses of Compile   

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