- " -
"Destructive" Operations
"Hello
World," Lisp Style
"Hello, World," Lisp Style
"There Is No List
- * -
*FEATURES* and Read-Time Conditionalization
- A -
Accessor Functions
Adding Inheritance and Tagged Structures
AllegroServe
An Abstraction Emerges
Analyzing the Results
AND
OR, and NOT
And More ---
AND, OR, and NOT
Anonymous Functions
Assignment
- B -
B
Back Cover
Basic Formatting
Basic Math
Better Result Reporting
Beyond Simple Macros
Binary Format Basics
Bit of Package and Symbol Vocabulary
Boilerplate HTML
Breaking Open the Black Box
Bulk Reads
- C -
C
CDs and Records
Chapter 1: Introduction - Why Lisp?
Chapter 10: Numbers
Characters, and Strings
Chapter 10: Numbers, Characters, and Strings
Chapter 11: Collections
Chapter 12: They Called It LISP for a Reason - List Processing
Chapter 13: Beyond Lists - Other Uses for Cons Cells
Chapter 14: Files and File I/O
Chapter 15: Practical - A Portable Pathname Library
Chapter 16: Object Reorientation - Generic Functions
Chapter 17: Object Reorientation - Classes
Chapter 18: Few FORMAT Recipes
Chapter 19: Beyond Exception Handling - Conditions and Restarts
Chapter 2: Lather
Rinse, Repeat - A Tour of the REPL
Chapter 2: Lather, Rinse, Repeat - A Tour of the REPL
Chapter 20: The Special Operators
Chapter 21: Programming in the Large - Packages and Symbols
Chapter 22: LOOP for Black Belts
Chapter 23: Practical - A Spam Filter
Chapter 24: Practical - Parsing Binary Files
Chapter 25: Practical - An ID3 Parser
Chapter 26: Practical - Web Programming with AllegroServe
Chapter 27: Practical - An MP3 Database
Chapter 28: Practical - A Shoutcast Server
Chapter 29: Practical - An MP3 Browser
Chapter 3: Practical - A Simple Database
Chapter 30: Practical - An HTML Generation Library
the Interpreter
Chapter 30: Practical - An HTML Generation Library, the Interpreter
Chapter 31: Practical - An HTML Generation Library
the Compiler
Chapter 31: Practical - An HTML Generation Library, the Compiler
Chapter 32: Conclusion - What?s Next?
Chapter 32: Conclusion - What's Next?
Chapter 4: Syntax and Semantics
Chapter 5: Functions
Chapter 6: Variables
Chapter 7: Macros - Standard Control Constructs
Chapter 8: Macros - Defining Your Own
Chapter 9: Practical - Building a Unit Test Framework
Character and Integer Directives
Character Comparisons
Character Escaping
Characters
Class-Allocated Slots
Closing Files
Combining Probabilities
Combining Recycling with Shared Structure
Comment Frames
Composite Structures
COND
Condition Handlers
Conditional Execution
Conditional Formatting
Conditions
Constants
Constructing New Pathnames
Controlling Evaluation
Cookies
Counting Loops
Couple of Utility Functions
- D -
D
DEFCLASS
DEFGENERIC
Defining a Package
Defining a Schema
Defining New Functions
Defining Your Own Packages
DEFMACRO
DEFMETHOD
Delivering Applications
Designing a Domain-Specific Language
Designing the Macros
Destructuring Variables
DESTRUCTURING-BIND
Detecting Tag Padding
DO
DOLIST and DOTIMES
Dynamic
a.k.a. Special, Variables
Dynamic, a.k.a. Special, Variables
- E -
E
English-Language Directives
Equals-Then Iteration
EVAL-WHEN
Experimenting in the REPL
Extracting Information from an ID3 Tag
- F -
F
File Output
Filenames
Filing CDs
Finding a Playlist
Fixing the Return Value
Floating-Point Directives
FOO Macros
FOO Special Operators
FORMAT Directives
Formatting Lisp Code
Free Your Mind: Interactive Programming
Function Calls
Function Parameter Lists
Function Return Values
Functional Programming and Lists
Functions As Data
a.k.a. Higher-Order Functions
Functions As Data, a.k.a. Higher-Order Functions
- G -
G
Generalized Assignment
Generating Dynamic Content with AllegroServe
Generating HTML
Generating the Expansion
Generic Functions and Classes
Generic Functions and Methods
Getting at the Results
Getting Up and Running with Lisp in a Box
Good Object-Oriented Design
- H -
H
Hash Table Iteration
Hash Tables
Hierarchy of Tests
Higher Math
Higher-Order Function Variants
Hop
Skip, Jump
Hop, Skip, Jump
How Pathnames Represent Filenames
How the Reader Uses Packages
HTML Macros
HTML Processor Interface
- I -
I
ID3 Frames
ID3 Tag Header
Implementing Shoutcast
Importing Individual Names
Improving the User Interaction
Indenting Printer
Index
Inserting Values
Integer Types
Interacting with the File System
Interfacing with Other Languages
Inverse Chi Square
Iteration
Iteration Control
- J -
J
- K -
K
Keeping Track of Inherited Slots
Keyword Parameters
- L -
L
Lexical Variables and Closures
List of Figures
List of Sidebars
List of Tables
Listing a Directory
List-Manipulation Functions
Local Flow of Control
Local Variables
Looking at the Database Contents
Lookup Tables: Alists and Plists
Looping
Looping Over Collections and Packages
- M -
M
Macro Expansion Time vs. Runtime
Macro Parameters
Macros
Macro-Writing Macros
Make It Work
Make It Right, Make It Fast
Make It Work, Make It Right, Make It Fast
Making the Dream a Reality
Manipulating the Lexical Environment
Manipulating the Playlist
Mapping
Matching Functions
Method Combination
Mixing Different Parameter Types
Multimethods
Multiple Inheritance
Multiple Values
- N -
N
Numbers
Numeric Comparisons
Numeric Literals
- O -
O
Object Initialization
Optional Parameters
Other Database Operations
Other Kinds of I/O
Other Method Combinations
Other Special Operators
Other Structures
Other Uses for Conditions
Other Ways to Modify Places
- P -
P
Package Gotchas
Packaging Mechanics
Packaging Reusable Libraries
Per-Word Statistics
Playlists As Song Sources
Plugging the Leaks
Practical Common Lisp
Primitive Binary Types
Providing Multiple Restarts
Putting It All Together
- Q -
Q
Query Parameter Types
Query Parameters
Querying the Database
- R -
R
Reading Binary Data
Reading Binary Objects
Refactoring
Removing Duplication and Winning Big
Rest Parameters
Restarts
Running the App
- S -
S
Sample Macro: do-primes
Saving and Loading the Database
Saving Your Work
Sequence Iterating Functions
Sequence Mapping Functions
Sequence Predicates
Sets
Setting Up and Tearing Down
S-expressions
S-expressions As Lisp Forms
Slot Specifiers
Slots and Inheritance
Small Application Framework
Song Sources
Sorting and Merging
Special Operators
String Comparisons
String Types
Strings
Strings in Binary Files
Structure of an ID3v2 Tag
Subsequence Manipulations
Subtypes of Vector
Supporting Multiple Versions of ID3
- T -
T
Table of Contents
Tagged Structures
Termination Tests
Testing a File?s Existence
Testing a File's Existence
Testing the Filter
Text Information Frames
The API
The Basic Evaluation Rule
The Browse Page
The Current Object Stack
The End of the Line
The FOO Language
The FORMAT Function
The Heart of a Spam Filter
The Implementation
The Lisp Way
The Mighty LOOP
The Parts of a LOOP
The Playlist
The Pretty Printer Backend
The Public API
The Standard Method Combination
The Story of Mac: A Just-So Story
Three Standard Packages
To Be Continued ---
Training the Filter
Truth
Falsehood, and Equality
Truth, Falsehood, and Equality
Two First Tries
Two Representations of Directory Names
Typographical Conventions
- U -
U
Unconditional Execution
Unwinding the Stack
Updating Existing Records - Another Use for WHERE
- V -
V
Value Accumulation
Vectors
Vectors As Sequences
Versioned Concrete Frame Classes
Versioned Frame Base Classes
- W -
W
Walking a Directory Tree
What Frames Do You Actually Need?
What?s Next
What?s Next?
What's Next
What's Next?
WHEN and UNLESS
Where It Began
Where to Go Next
Who This Book Is For
Whole Sequence Manipulations
Why Lisp?
WITH-SLOTS and WITH-ACCESSORS
Wrapping Up
Writing Binary Objects
- X -
X
- Y -
Y
- Z -
Z
