Purchase textbook

Common LISP,

Edition 2 The Language

Editors: By Guy Steele

Publication Date: 15 Jun 1984

0 Reviews

Inaccessible, or known limited accessibility

Ways Of Reading

This e-publication is accessible to the full extent that the file format and types of content allow, on a specific reading device, by default, without necessarily including any additions such as textual descriptions of images or enhanced navigation.

Navigation

The contents of the PDF have been tagged to permit access by assistive technologies as per PDF-UA-1 standard.
Page breaks included from the original print source

Additional Accessibility Information

All (or substantially all) textual matter is arranged in a single logical reading order (including text that is visually presented as separate from the main text flow, e.g., in boxouts, captions, tables, footnotes, endnotes, citations, etc.). Non-textual content is also linked from within this logical reading order. (Purely decorative non-text content can be ignored).
The language of the text has been specified (e.g., via the HTML or XML lang attribute) to optimise text-to-speech (and other alternative renderings), both at the whole document level and, where appropriate, for individual words, phrases or passages in a different language.

Conformance

The publication was certified on 20250728
Accessibility addendum
For detailed accessibility information, see Elsevier’s website at https://www.elsevier.com/about/accessibility
For queries regarding accessibility information, contact [email protected]

Note

This product relies on 3rd party tooling which may impact the accessibility features visible in inspection copies. All accessibility features mentioned would be present in the purchased version of the title.

The defacto standard - a must-have for all LISP programmers.

In this greatly expanded edition of the defacto standard, you'll learn about the nearly 200 changes already made since original publication - and find out about gray areas likely to be revised later. Written by the Vice- Chairman of X3J13 (the ANSI
committee responsible for the standardization of Common Lisp) and co-developer of the language itself, the new edition contains the entire text of the first edition plus six completely new chapters. They cover: - CLOS, the Common Lisp Object System, with new features to support function overloading and object-oriented programming, plus complete technical specifications * Loops, a powerful control structure for multiple variables * Conditions, a generalization of the error signaling mechanism * Series and generators * Plus other subjects not part of the ANSI standards but of interest to professional programmers. Throughout, you'll find fresh examples, additional clarifications, warnings, and tips - all presented with the author's customary vigor and wit.

About the author

By Guy Steele, Thinking Machines Corporation

Contents

Preface (Second Edition)

Acknowledgments (Second Edition)

Acknowledgments (First Edition)

1. Introduction

1.1. Purpose

1.2. Notational Conventions

1.2.1. Decimal Numbers

1.2.2. Nil, False, and the Empty List

1.2.3. Evaluation, Expansion, and Equivalence

1.2.4. Errors

1.2.5. Descriptions of Functions and Other Entities

1.2.6. The Lisp Reader

1.2.7. Overview of Syntax

2. Data Types

2.1. Numbers

2.1.1. Integers

2.1.2. Ratios

2.1.3. Floating-Point Numbers

2.1.4. Complex Numbers

2.2. Characters

2.2.1. Standard Characters

2.2.2. Line Divisions

2.2.3. Non-standard Characters

2.2.4. Character Attributes

2.2.5. String Characters

2.3. Symbols

2.4. Lists and Conses

2.5. Arrays

2.5.1. Vectors

2.5.2. Strings

2.5.3. Bit-Vectors

2.6. Hash Tables

2.7. Readtables

2.8. Packages

2.9. Pathnames

2.10. Streams

2.11. Random-States

2.12. Structures

2.13. Functions

2.14. Unreadable Data Objects

2.15. Overlap, Inclusion, and Disjointness of Types

3. Scope and Extent

4. Type Specifiers

4.1. Type Specifier Symbols

4.2. Type Specifier Lists

4.3. Predicating Type Specifiers

4.4. Type Specifiers That Combine

4.5. Type Specifiers That Specialize

4.6. Type Specifiers That Abbreviate

4.7. Defining New Type Specifiers

4.8. Type Conversion Function

4.9. Determining the Type of an Object

4.10. Type Upgrading

5. Program Structure

5.1. Forms

5.1.1. Self-Evaluating Forms

5.1.2. Variables

5.1.3. Special Forms

5.1.4. Macros

5.1.5. Function Calls

5.2. Functions

5.2.1. Named Functions

5.2.2. Lambda-Expressions

5.3. Top-Level Forms

5.3.1. Defining Named Functions

5.3.2. Declaring Global Variables and Named Constants

5.3.3. Control of Time of Evaluation

6. Predicates

6.1. Logical Values

6.2. Data Type Predicates

6.2.1. General Type Predicates

6.2.2. Specific Data Type Predicates

6.3. Equality Predicates

6.4. Logical Operators

7. Control Structure

7.1. Constants and Variables

7.1.1. Reference

7.1.2. Assignment

7.2. Generalized Variables

7.3. Function Invocation

7.4. Simple Sequencing

7.5. Establishing New Variable Bindings

7.6. Conditionals

7.7. Blocks and Exits

7.8. Iteration

7.8.1. Indefinite Iteration

7.8.2. General Iteration

7.8.3. Simple Iteration Constructs

7.8.4. Mapping

7.8.5. The "Program Feature"

7.9. Structure Traversal and Side Effects

7.10. Multiple Values

7.10.1. Constructs for Handling Multiple Values

7.10.2. Rules Governing the Passing of Multiple Values

7.11. Dynamic Non-Local Exits

8. Macros

8.1. Macro Definition

8.2. Macro Expansion

8.3. Destructuring

8.4. Compiler Macros

8.5. Environments

9. Declarations

9.1. Declaration Syntax

9.2. Declaration Specifiers

9.3. Type Declaration for Forms

10. Symbols

10.1. The Property List

10.2. The Print Name

10.3. Creating Symbols

11. Packages

11.1. Consistency Rules

11.2. Package Names

11.3. Translating Strings to Symbols

11.4. Exporting and Importing Symbols

11.5. Name Conflicts

11.6. Built-in Packages

11.7. Package System Functions and Variables

11.8. Modules

11.9. An Example

12. Numbers

12.1. Precision, Contagion, and Coercion

12.2. Predicates on Numbers

12.3. Comparisons on Numbers

12.4. Arithmetic Operations

12.5. Irrational and Transcendental Functions

12.5.1. Exponential and Logarithmic Functions

12.5.2. Trigonometric and Related Functions

12.5.3. Branch Cuts, Principal Values, and Boundary Conditions in the Complex Plane

12.6. Type Conversions and Component Extractions on Numbers

12.7. Logical Operations on Numbers

12.8. Byte Manipulation Functions

12.9. Random Numbers

12.10. Implementation Parameters

13. Characters

13.1. Character Attributes

13.2. Predicates on Characters

13.3. Character Construction and Selection

13.4. Character Conversions

13.5. Character Control-Bit Functions

14. Sequences

14.1. Simple Sequence Functions

14.2. Concatenating, Mapping, and Reducing Sequences

14.3. Modifying Sequences

14.4. Searching Sequences for Items

14.5. Sorting and Merging

15. Lists

15.1. Conses

15.2. Lists

15.3. Alteration of List Structure

15.4. Substitution of Expressions

15.5. Using Lists as Sets

15.6. Association Lists

16. Hash Tables

16.1. Hash Table Functions

16.2. Primitive Hash Function

17. Arrays

17.1. Array Creation

17.2. Array Access

17.3. Array Information

17.4. Functions on Arrays of Bits

17.5. Fill Pointers

17.6. Changing the Dimensions of an Array

18. Strings

18.1. String Access

18.2. String Comparison

18.3. String Construction and Manipulation

19. Structures

19.1. Introduction to Structures

19.2. How to Use Defstruct

19.3. Using the Automatically Defined Constructor Function

19.4. Defstruct Slot-Options

19.5. Defstruct Options

19.6. By-Position Constructor Functions

19.7. Structures of Explicitly Specified Representational Type

19.7.1. Unnamed Structures

19.7.2. Named Structures

19.7.3. Other Aspects of Explicitly Specified Structures

20. The Evaluator

20.1. Run-Time Evaluation of Forms

20.2. The Top-Level Loop

21. Streams

21.1. Standard Streams

21.2. Creating New Streams

21.3. Operations on Streams

22. Input/Output

22.1. Printed Representation of Lisp Objects

22.1.1. What the Read Function Accepts

22.1.2. Parsing of Numbers and Symbols

22.1.3. Macro Characters

22.1.4. Standard Dispatching Macro Character Syntax

22.1.5. TheReadtable

22.1.6. What the Print Function Produces

22.2. Input Functions

22.2.1. Input from Character Streams

22.2.2. Input from Binary Streams

22.3. Output Functions

22.3.1. Output to Character Streams

22.3.2. Output to Binary Streams

22.3.3. Formatted Output to Character Streams

22.4. Querying the User

23. File System Interface

23.1. File Names

23.1.1. Pathnames

23.1.2. Case Conventions

23.1.3. Structured Directories

23.1.4. Extended Wildcards

23.1.5. Logical Pathnames

23.1.6. Pathname Functions

23.2. Opening and Closing Files

23.3. Renaming, Deleting, and Other File Operations

23.4. Loading Files

23.5. Accessing Directories

24. Errors

24.1. General Error-Signaling Functions

24.2. Specialized Error-Signaling Forms and Macros

24.3. Special Forms for Exhaustive Case Analysis

25. Miscellaneous Features

25.1. The Compiler

25.1.1. Compiler Diagnostics

25.1.2. Compiled Functions

25.1.3. Compilation Environment

25.1.4. Similarity of Constants

25.2. Documentation

25.3. Debugging Tools

25.4. Environment Inquiries

25.4.1. Time Functions

25.4.2. Other Environment Inquiries

25.5. Identity Function

26. Loop

26.1. Introduction

26.2. How the Loop Facility Works

26.3. Parsing Loop Clauses

26.3.1. Order of Execution

26.3.2. Kinds of Loop Clauses

26.3.3. Loop Syntax

26.4. User Extensibility

26.5. Loop Constructs

26.6. Iteration Control

26.7. End-Test Control

26.8. Value Accumulation

26.9. Variable Initializations

26.10. Conditional Execution

26.11. Unconditional Execution

26.12. Miscellaneous Features

26.12.1. Data Types

26.12.2. Destructuring

27. Pretty Printing

27.1. Introduction

27.2. Pretty Printing Control Variables

27.3. Dynamic Control of the Arrangement of Output

27.4. Format Directive Interface

27.5. Compiling Format Control Strings

27.6. Pretty Printing Dispatch Tables

28. Common Lisp Object System

28.1. Programmer Interface Concepts

28.1.1. Error Terminology

28.1.2. Classes

28.1.3. Inheritance

28.1.4. Integrating Types and Classes

28.1.5. Determining the Class Precedence List

28.1.6. Generic Functions and Methods

28.1.7. Method Selection and Combination

28.1.8. Meta-objects

28.1.9. Object Creation and Initialization

28.1.10. Redefining Classes

28.1.11. Changing the Class of an Instance

28.2. Functions in the Programmer Interface

29. Conditions

29.1. Introduction

29.2. Changes in Terminology

29.3. Survey of Concepts

29.3.1. Signaling Errors

29.3.2. Trapping Errors

29.3.3. Handling Conditions

29.3.4. Object-Oriented Basis of Condition Handling

29.3.5. Restarts

29.3.6. Anonymous Restarts

29.3.7. Named Restarts

29.3.8. Restart Functions

29.3.9. Comparison of Restarts and Catch/Throw

29.3.10. Generalized Restarts

29.3.11. Interactive Condition Handling

29.3.12. Serious Conditions

29.3.13. Non-Serious Conditions

29.3.14. Condition Types

29.3.15. Signaling Conditions

29.3.16. Resignaling Conditions

29.3.17. Condition Handlers

29.3.18. Printing Conditions

29.4. Program Interface to the Condition System

29.4.1. Signaling Conditions

29.4.2. Assertions

29.4.3. Exhaustive Case Analysis

29.4.4. Handling Conditions

29.4.5. Defining Conditions

29.4.6. Creating Conditions

29.4.7. Establishing Restarts

29.4.8. Finding and Manipulating Restarts

29.4.9. Warnings

29.4.10. Restart Functions

29.4.11. Debugging Utilities

29.5. Predefined Condition Types

Appendix A. Series

A.l. Introduction

A.2. Series Functions

A.2.1. Scanners

A.2.2. Mapping

A.2.3. Truncation and Other Simple Transducers

A.2.4. Conditional and Other Complex Transducers

A.2.5. Collectors

A.2.6. Alteration of Series

A.3. Optimization

A.3.1. Basic Restrictions

A.3.2. Constraint Cycles

A.3.3. Defining New Series Functions

A.3.4. Declarations

A.4. Primitives

Appendix B. Generators and Gatherers

B.l. Introduction

B.2. Generators

B.3. Gatherers

B.4. Discussion

Appendix C. Backquote

References

Index of X3J13 Votes

Other Indexes

ISBN: 9781555580414

Page Count: 1056

Retail Price :

Programmers working with LISP