Table of contents for Practical COMMON LISP / Peter Seibel.

Bibliographic record and links to related information available from the Library of Congress catalog.

Note: Contents data are machine generated based on pre-publication provided by the publisher. Contents may have variations from the printed book or be incomplete or contain other coding.


Counter
Contents
About the Author
About the Technical Reviewer
Acknowledgments
Typographical Conventions
CHAPTER 1 INTRODUCTION: WHY LISP?
Why Lisp?
Where It Began
Who This Book Is For
CHAPTER 2 LATHER, RINSE, REPEAT: A TOUR OF THE REPL
Choosing a Lisp Implementation
Getting Up and Running with Lisp in a Box
Free Your Mind: Interactive Programming
Experimenting in the REPL
"Hello, World," Lisp Style
Saving Your Work
CHAPTER 3 PRACTICAL: A SIMPLE DATABASE
CDs and Records
Filing CDs
Looking at the Database Contents
Improving the User Interaction
Saving and Loading the Database
Querying the Database
Updating Existing Records-Another Use for WHERE
Removing Duplication and Winning Big
Wrapping Up
CHAPTER 4 SYNTAX AND SEMANTICS
What's with All the Parentheses?
Breaking Open the Black Box
S-expressions
S-expressions As Lisp Forms
Function Calls
Special Operators
Macros
Truth, Falsehood, and Equality
Formatting Lisp Code
CHAPTER 5 FUNCTIONS
Defining New Functions
Function Parameter Lists
Optional Parameters
Rest Parameters
Keyword Parameters
Mixing Different Parameter Types
Function Return Values
Functions As Data, a.k.a. Higher-Order Functions
Anonymous Functions
CHAPTER 6 VARIABLES
Variable Basics
Lexical Variables and Closures
Dynamic, a.k.a. Special, Variables
Constants
Assignment
Generalized Assignment
Other Ways to Modify Places
CHAPTER 7 MACROS: STANDARD CONTROL CONSTRUCTS
WHEN and UNLESS
COND
AND, OR, and NOT
Looping
DOLIST and DOTIMES
DO
The Mighty LOOP
CHAPTER 8 MACROS: DEFINING YOUR OWN
The Story of Mac: A Just-So Story
Macro Expansion Time vs. Runtime
DEFMACRO
A Sample Macro: do-primes
Macro Parameters
Generating the Expansion
Plugging the Leaks
Macro-Writing Macros
Beyond Simple Macros
CHAPTER 9 PRACTICAL: BUILDING A UNIT TEST FRAMEWORK
Two First Tries
Refactoring
Fixing the Return Value
Better Result Reporting
An Abstraction Emerges
A Hierarchy of Tests
Wrapping Up
CHAPTER 10 NUMBERS, CHARACTERS, AND STRINGS
Numbers
Numeric Literals
Basic Math
Numeric Comparisons
Higher Math
Characters
Character Comparisons
Strings
String Comparisons
CHAPTER 11 COLLECTIONS
Vectors
Subtypes of Vector
Vectors As Sequences
Sequence Iterating Functions
Higher-Order Function Variants
Whole Sequence Manipulations
Sorting and Merging
Subsequence Manipulations
Sequence Predicates
Sequence Mapping Functions
Hash Tables
Hash Table Iteration
CHAPTER 12 THEY CALLED IT LISP FOR A REASON: LIST 
PROCESSING
"There Is No List"
Functional Programming and Lists
"Destructive" Operations
Combining Recycling with Shared Structure
List-Manipulation Functions
Mapping
Other Structures
CHAPTER 13 BEYOND LISTS: OTHER USES FOR CONS CELLS
Trees
Sets
Lookup Tables: Alists and Plists
DESTRUCTURING-BIND
CHAPTER 14 FILES AND FILE I/O
Reading File Data
Reading Binary Data
Bulk Reads
File Output
Closing Files
Filenames
How Pathnames Represent Filenames
Constructing New Pathnames
Two Representations of Directory Names
Interacting with the File System
Other Kinds of I/O
CHAPTER 15 PRACTICAL: A PORTABLE PATHNAME LIBRARY
The API
*FEATURES* and Read-Time Conditionalization
(in-package #:com.gigamonkeys.pathnames)
Listing a Directory
Testing a File's Existence
Walking a Directory Tree
CHAPTER 16 OBJECT REORIENTATION: GENERIC FUNCTIONS
Generic Functions and Classes
Generic Functions and Methods
DEFGENERIC
DEFMETHOD
Method Combination
The Standard Method Combination
Other Method Combinations
Multimethods
To Be Continued...
CHAPTER 17 OBJECT REORIENTATION: CLASSES
DEFCLASS
Slot Specifiers
Object Initialization
Accessor Functions
WITH-SLOTS and WITH-ACCESSORS
Class-Allocated Slots
Slots and Inheritance
Multiple Inheritance
Good Object-Oriented Design
CHAPTER 18 A FEW FORMAT RECIPES
The FORMAT Function
FORMAT Directives
Basic Formatting
Character and Integer Directives
Floating-Point Directives
English-Language Directives
Conditional Formatting
Iteration
Hop, Skip, Jump
And More...
CHAPTER 19 BEYOND EXCEPTION HANDLING: CONDITIONS 
AND RESTARTS
The Lisp Way
Conditions
Condition Handlers
Restarts
Providing Multiple Restarts
Other Uses for Conditions
CHAPTER 20 THE SPECIAL OPERATORS
Controlling Evaluation
Manipulating the Lexical Environment
Local Flow of Control
Unwinding the Stack
Multiple Values
EVAL-WHEN
Other Special Operators
CHAPTER 21 PROGRAMMING IN THE LARGE: PACKAGES AND 
SYMBOLS
How the Reader Uses Packages
A Bit of Package and Symbol Vocabulary
Three Standard Packages
Defining Your Own Packages
Packaging Reusable Libraries
Importing Individual Names
Packaging Mechanics
Package Gotchas
CHAPTER 22 LOOP FOR BLACK BELTS
The Parts of a LOOP
Iteration Control
Counting Loops
Looping Over Collections and Packages
Equals-Then Iteration
Local Variables
Destructuring Variables
Value Accumulation
Unconditional Execution
Conditional Execution
Setting Up and Tearing Down
Termination Tests
Putting It All Together
CHAPTER 23 PRACTICAL: A SPAM FILTER
The Heart of a Spam Filter
Training the Filter
Per-Word Statistics
Combining Probabilities
Inverse Chi Square
Training the Filter
Testing the Filter
A Couple Utility Functions
Analyzing the Results
What's Next
CHAPTER 24 PRACTICAL: PARSING BINARY FILES
Binary Files
Binary Format Basics
Strings in Binary Files
Composite Structures
Designing the Macros
Making the Dream a Reality
Reading Binary Objects
Writing Binary Objects
Adding Inheritance and Tagged Structures
Keeping Track of Inherited Slots
Tagged Structures
Primitive Binary Types
The Current Object Stack
CHAPTER 25 PRACTICAL: AN ID3 PARSER
Structure of an ID3v2 Tag
Defining a Package
Integer Types
String Types
ID3 Tag Header
ID3 Frames
Detecting Tag Padding
Supporting Multiple Version of ID3
Versioned Frame Base Classes
Versioned Concrete Frame Classes
What Frames Do You Actually Need?
Text Information Frames
Comment Frames
Extracting Information from an ID3 Tag
CHAPTER 26 PRACTICAL: WEB PROGRAMMING WITH 
ALLEGROSERVE
A 30-Second Intro to Server-Side Web Programming
AllegroServe
Generating Dynamic Content with AllegroServe
Generating HTML
HTML Macros
Query Parameters
Cookies
A Small Application Framework
The Implementation
CHAPTER 27 PRACTICAL: AN MP3 DATABASE
The Database
Defining a Schema
Inserting Values
Querying the Database
Matching Functions
Getting at the Results
Other Database Operations
CHAPTER 28 PRACTICAL: A SHOUTCAST SERVER
The Shoutcast Protocol
Song Sources
Implementing Shoutcast
CHAPTER 29 PRACTICAL: AN MP3 BROWSER
Playlists
Playlists As Song Sources
Manipulating the Playlist
Query Parameter Types
Boilerplate HTML
The Browse Page
The Playlist
Finding a Playlist
Running the App
CHAPTER 30 PRACTICAL: AN HTML GENERATION LIBRARY, 
THE INTERPRETER
Designing a Domain-Specific Language
The FOO Language
Character Escaping
Indenting Printer
HTML Processor Interface
The Pretty Printer Backend
The Basic Evaluation Rule
What's Next?
CHAPTER 31 PRACTICAL: AN HTML GENERATION LIBRARY, 
THE COMPILER
The Compiler
FOO Special Operators
FOO Macros
The Public API
The End of the Line
CHAPTER 32 CONCLUSION: WHAT'S NEXT?
Finding Lisp Libraries
Interfacing with Other Languages
Make It Work, Make It Right, Make It Fast
Delivering Applications
Where to Go Next
Index

Library of Congress Subject Headings for this publication:

COMMON LISP (Computer program language).