Name: Common LISP By Guy Steele (Thinking Machines Corporation)
SKU: 9781555580414
Price: 65.46 USD
Availability: InStock

Common LISP Summary

Common LISP: The Language by Guy Steele (Thinking Machines Corporation)

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.

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

Additional information

Sku

CIN1555580416G

ISBN 13

9781555580414

ISBN 10

1555580416

Title

Common LISP: The Language by Guy Steele (Thinking Machines Corporation)

Author

Guy Steele (Thinking Machines Corporation)

Series

HP Technologies

Condition

Used - Good

Binding type

Paperback

Publisher

Elsevier Science & Technology

Year published

1990-03-21

Number of pages

1029

Prizes

N/A

Cover note

Book picture is for illustrative purposes only, actual binding, cover or edition may vary.

Note

This is a used book - there is no escaping the fact it has been read by someone else and it will show signs of wear and previous use. Overall we expect it to be in good condition, but if you are not entirely satisfied please get in touch with us

Common LISP Guy Steele (Thinking Machines Corporation)

Common LISP by Guy Steele (Thinking Machines Corporation)

Summary

Faster Shipping

Common LISP Summary

Common LISP: The Language by Guy Steele (Thinking Machines Corporation)

Table of Contents

Additional information

Customer Reviews - Common LISP