Common LISP

Common LISP

The Language

2nd Edition - June 15, 1984

Write a review

  • Author: Guy Steele
  • eBook ISBN: 9780080502267

Purchase options

Purchase options
DRM-free (PDF)
Sales tax will be calculated at check-out

Institutional Subscription

Free Global Shipping
No minimum order

Description

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 ANSIcommittee 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.

Readership

Programmers working with LISP

Table of Contents


  • 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


Product details

  • No. of pages: 1029
  • Language: English
  • Copyright: © Digital Press 1990
  • Published: June 15, 1984
  • Imprint: Digital Press
  • eBook ISBN: 9780080502267

About the Author

Guy Steele

Affiliations and Expertise

Thinking Machines Corporation

Ratings and Reviews

Write a review

There are currently no reviews for "Common LISP"