Lisp, 3/e(Paperback)
Patrick Winston, Berthold Horn
- 出版商: Addison Wesley
- 出版日期: 2019-07-12
- 售價: $1,980
- 貴賓價: 9.5 折 $1,881
- 語言: 英文
- 頁數: 640
- 裝訂: Paperback
- ISBN: 0201083191
- ISBN-13: 9780201083194
-
相關分類:
Functional-programming
立即出貨(限量) (庫存=1)
買這商品的人也買了...
-
$1,093Artificial Intelligence: A New Synthesis (Paperback)
-
$1,830$1,739 -
$999AI Application Programming (Paperback)
-
$3,310$3,145 -
$150$119 -
$650$553 -
$550$468 -
$1,200$1,176 -
$990$891 -
$600$480 -
$650$553 -
$480$432 -
$580$458 -
$750$638 -
$520$442 -
$650$553 -
$490$417 -
$520$442 -
$450$356 -
$420$357 -
$420$328 -
$580$458 -
$580$493 -
$480$379 -
$1,570$1,492
商品描述
Table Of Contents
(NOTE: Each chapter ends with a Summary.)
TABLE OF CONTENTS.
1. Understanding Symbol Manipulation.
Lisp Helps Make Computers Intelligent.
Lisp Promotes Productivity and Facilitates Education.
Lisp Is the Right Symbol-Manipulation Language To Learn.
CommonLisp Is the Right Lisp To Learn.
Beware of False Myths.
References.
2. Basic Lisp Primitives.
Lisp Procedures and Data Are Symbolic Expressions.
Lists Are Like Bowls.
Quoting Stops Evaluation.
SETF Assigns Values to Symbols.
SETF Accepts Multiple Symbol-Value Pairs.
Certain Atoms Evaluate to Themselves.
CONS, APPEND, and LIST Do Not Alter Symbol Values.
NTHCDR, BUTLAST, and LAST Shorten Lists.
LENGTH and REVERSE Work on Top-Level Elements.
ASSOC Looks for Indexed Sublists.
Lisp Offers Integers, Ratios, and Floating-Point Numbers, among Others.
A Few Primitives for Numbers Round Out a Basic Repertoire.
3. Procedure Definition and Binding.
Parameter Variable Values Are Isolated by Virtual Fences.
Special Variable Values Are Not Isolated by Virtual Fences.
Procedures Match Parameters to Arguments.
LET Forms Produce Nested Fences.
LET Forms Evaluate Initial-Value Forms in Parallel.
LET* Forms Evaluate Initial-Value Forms Sequentially.
Progressive Envelopment and Comment Translation Help Define New Procedures.
4. Predicates and Conditionals.
MEMBER Tests for List Membership.
Keyword Arguments Modify Behavior.
NIL Is Equivalent to the Empty List.
NULL and ENDP Are Empty-List Predicates.
There Are Many Number Predicates.
Predicates Help COND Choose among Alternatives.
CASE Is Still Another Conditional.
Conditionals Enable DEFUN To Do Much More.
Problem Reduction Helps Define New Procedures.
5. Procedure Abstraction and Recursion.
Recursion Allows Procedures To Use Themselves
Recursion Can Be Efficient.
Recursion Can Be Used To Analyze Nested Expressions.
Optional Parameters Eliminate the Need for Many Auxiliaries.
Advanced Programmers Use Rest, Key, and Aux Parameters
Only a Few Lisp Primitives Are Really Necessary.
References.
6. Data Abstraction and Mapping.
Data Abstraction Facilitates Progress.
You Should Use Readers, Constructors, and Writers Liberally.
It Is Useful To Transform and To Filter.
Recursive Procedures Can Transform and Filter.
Recursive Procedures Can Count and Find.
Cliches Embody Important Programming Knowledge.
REMOVE-IF and REMOVE-IF-NOT Simplify Filtering Operations.
COUNT-IF and FIND-IF Simplify Counting and Finding Operations.
FUNCALL and APPLY Also Take a Procedure Argument.
LAMBDA Defines Anonymous Procedures.
References.
7. Iteration on Numbers and Lists.
DOLIST Supports Iteration on Lists.
DO Is More General than DOLIST and DOTIMES.
LOOP Never Stops, Almost.
PROG1 and PROGN Handle Sequences Explicitly.
8. File Editing, Compiling, and Loading.
File Specifications Tend to Have Baroque Forms.
Emacs Is a Particularly Powerful Lisp Editor.
LOAD Causes Lisp To Read from Files.
References.
9. Printing and Reading.
FORMAT Enables Exotic Printing.
WITH-OPEN-FILE Enables Reading from Files.
Optional Arguments in READ Forms Specify End-of-File Treatment.
WITH-OPEN-FILE Enables Printing to Files.
READ Does Not Evaluate Expressions, but EVAL Evaluates Twice.
READ-LINE and READ-CHAR Read Strings and Characters.
10. Rules for Good Programming and Tools for Debugging.
Big Programs Require Abstraction and Modularity.
TRACE Causes Procedures To Print Their Arguments and Values.
STEP Causes Procedures To Proceed One Step at a Time.
BREAK Stops Evaluation so that You Can Evaluate Forms.
TIME, DESCRIBE, and DRIBBLE Are Helpful Too.
Debugging Is Implementation Specific.
References.
11. Properties and Arrays.
Properties Enable Storage in Symbolically Indexed Places.
Arrays Enable Storage in Numerically Indexed Places.
12. Macros and Backquote.
The Backquote Mechanism Simplifies Template Filling.
The Backquote Mechanism Simplifies Macro Writing.
Optional, Rest, and Key Parameters Enable More Powerful Macros.
Macros Deserve Their Own File.
13. Structures.
Structure Types Enable Storage in Procedurally Indexed Places.
Individual Structure Types Are New Data Types.
One Structure Type Can Include the Fields of Another.
Structure Types Are Important Components of Big Systems.
DEFSTRUCTs Deserve Their Own File.
14. Classes and Generic Functions.
You Can Make Ordinary Procedures Data Driven, Albeit Awkwardly.
Methods Are Procedures Selected from Generic Functions by Argument Types.
Classes Resemble Structure Types but Resonate Better with Generic Functions.
Any Nonoptional Argument's Class Can Help Select a Method.
Classes Enable Method Inheritance.
The Most Specific Method Takes Precedence over the Others.
Parameter Order Helps Determine Method Precedence.
Simple Rules Approximate the Complicated Class Precedence Algorithm.
Methods Can Be Specialized to Individual Instances.
Method Selection Involves Three Steps.
Object-Oriented Programming Offers Advantages, Not Magic.
References.
15. Lexical Variables, Generators, and Encapsulation.
LETs Produce Nested Fences.
Nested Fences Provide Variable Values.
Procedure Calls Usually Do Not Produce Nested Fences.
Nested Definitions do Produce Nested Fences.
Generators Produce Sequences.
Nameless Procedures Produce Nested Fences.
Nameless Procedures Can Be Assigned to Variables.
The Free Variables in Nameless Procedures Can Be Encapsulated.
Encapsulation Enables the Creation of Sophisticated Generators.
Generators Can Be Defined by other Procedures.
Nameless Procedures Become Lexical Closures.
References.
16. Special Variables.
Some Variables Are Declared To Be Special Forevermore.
Special-Variable Bindings Are Actually Kept on a Stack.
Some Variable Instances Can Be Special while Others Are Lexical.
Both Lexical and Special Variables Can Be Free Variables.
17. List Storage, Surgery, and Reclamation.
Lists Can Be Represented by Boxes and Pointers.
Boxes and Pointers Can Be Represented by Bytes.
APPEND Builds New Lists by Copying.
NCONC and DELETE Can Alter Box Contents Dangerously.
SETF Also Can Alter Box Contents Dangerously.
EQ Checks Pointers Only.
Garbage Collection Reclaims Abandoned Memory.
Lisp Allows You To Write Inefficient Procedures.
Simple Garbage Collectors Use the Mark and Sweep Approach.
Simulation Procedures Expose Garbage Collection Details.
SWEEP Collects Unmarked Chunks.
Marking Can Be Done without Recursion.
Our Nonrecursive Marking Procedure Leaves a Trail of Pointers.
Some Garbage Collectors Are Incremental.
18. Lisp in Lisp.
It Is Easy To Build a Simple Interpreter for a Lisplike Language.
Traces Show How MICRO-EVAL and MICRO-APPLY Work Together.
Closures Encapsulate Environments.
Special Variable Binding Can Be Arranged.
Lisp Does Call-by-Value Rather Than Call-by-Reference.
Lisp Can Be Defined in Lisp.
Fancy Control Structures Usually Start Out as Basic Lisp Interpreters.
19. Examples Involving Search.
Breadth-First and Depth-First Searches Are Basic Strategies.
Best-First Search and Hill-Climbing Require Sorting.
References.
20. Examples Involving Simulation.
Projects Involve Events and Tasks.
Structures Can Represent Events and Tasks.
Simulation Procedures Can Propagate Event Times.
Event and Task Structures Require Special Printing Procedures.
An Event List Keeps Simulation in Step with the Simulated Project.
21. The Blocks World with Classes and Methods.
The Blocks-World Program Handles Put-On Commands.
Object-Oriented Programming Shifts Attention from Procedures to Objects.
Object-Oriented Programming Begins with Class Specification.
Slot Readers Are Generic Functions.
The Blocks-World Program's Methods Are Transparent.
Before and After Methods Simplify Bookkeeping.
Slot Writers Are Generic Functions.
Object-Oriented Programming Enables Automatic Procedure Assembly.
You Can Control How Instances Are Printed.
The Number-Crunching Methods Can Be Ignored.
The Blocks-World Program Illustrates Abstraction.
References.
22. Answering Questions about Goals.
The Blocks-World Program Can Introspect into its Own Operation.
Remembering Generic Function Calls Creates a Goal Tree.
Macros Enable Method-Defining Procedures To Be Defined.
The Goal Tree Is Easy to Display.
The Goal Tree Answers Questions.
References.
23. Constraint Propagation.
Constraints Propagate Numbers through Arithmetic Boxes.
Constraints Propagate Probability Bounds through Logic Boxes.
Classes Represent Assertions and Logical Constraints.
Generic Functions Enforce Constraints.
More Information Moves Probability Bounds Closer.
References.
24. Symbolic Pattern Matching.
Matching Compares Patterns and Datums Element by Element.
Matching Is Easily Implemented by a Recursive Procedure.
Matching Is Better Implemented Using Procedure Abstraction.
Unification Is Generalized Matching.
References.
25. Streams and Delayed Evaluation.
Streams Are Sequences of Data Objects.
We Can Represent Streams Using Lists.
We Can Delay Evaluation by Encapsulation.
We Can Represent Streams Using Delayed Evaluation.
References.
26. Rule-Based Expert Systems and Forward Chaining.
Forward Chaining Means Working from Antecedents to Consequents.
We Use Streams To Represent Assertions and Rules.
Our Second Pass Concentrates on the Procedures that Surround MATCH.
Simple Rules Help Identify Animals.
Rules Facilitate Question Answering and Probability Computing.
Our Forward-Chaining Program Illustrates Abstraction.
References.
27. Backward Chaining and PROLOG.
Our Backward Chainer Borrows Procedures from our Forward Chainer.
Backward Chaining Means Working from Consequents to Antecedents.
Our Second Pass Concentrates on the Procedures that Surround MATCH and UNIFY.
Completing Our Backward-Chaining Program Involves a Few Auxiliary Procedures.
Simple Rules Help Identify Animals.
Our Backward Chainer Implements a Language like Prolog.
Our Backward-Chaining Program Illustrates Abstraction.
References.
28. Interpreting Transition Trees.
Procedures Can Produce Multiple Values.
Natural-Language Interfaces Produce Database Commands.
Transition Trees Capture English Syntax.
A Transition Tree Interpreter Follows an Explicit Description.
Multiple-Valued Procedures Embody Transition Trees.
Our Interpreter Uses Explicit Transition-Tree Descriptions.
We Use a Macro To Simplify Tree Definition.
A Read, Analyze, and Report Loop Adds a Finishing Touch.
References.
29. Compiling Transition Trees.
Transition Trees Can Be Compiled from Transparent Specifications.
Compilers Treat Programs as Data.
Compiled Programs Run Faster.
Compilers Are Usually Major Undertakings.
Lisp Itself Is Either Compiled or Interpreted.
30. Procedure-Writing Programs and Database Interfaces.
Grammars Can Be Sophisticated.
Answering Requests Is Done in Three Steps.
Most Database Commands Transform Relations into Relations.
English Questions Correspond to Database Commands.
Our Simulated Database Supports an Improved Grammar.
The Relational Database Can Be Faked.
The Database Illustrates Data Abstraction.
31. Finding Patterns in Images.
Generating All Possible Matches Helps Isolate the Correct Match.
Constraints Are Needed To Isolate the Correct Match.
The Search Tree Can Be Pruned Using Geometric Information.
Matches Have To Be Checked for Global Consistency.
Matching Is Harder if Mismatches Are Allowed.
Keeping Track of Mismatches Improves Efficiency.
The Cost of Filtering Has To Be Weighed against the Cost of Searching.
Multiple Matching Attempts Lead to Recognition.
Edges Provide More Constraint than Points.
References.
32. Converting Notations, Manipulating Matrices, and Finding Roots.
It Is Easy to Translate Infix Notation to Prefix.
Sparse Matrices Can Be Represented as Lists of Lists.
Complex Numbers Constitute Another Numeric Data Type.
Roots of Quadratic Equations Are Easy To Calculate.
Roots of Cubic Equations Can Be Calculated.
Roots of Quartic Equations Are Harder To Calculate.
References.
Appendix: The Computation of the Class Precedence List.
Make Initial Lists.
Make a List of Precedence Pairs.
Make a List of Precedence List Candidates.
Select a Candidate.
Shrink the List of Precedence Pairs. @AHEADS - Repeat.
Problem Solutions.
Glossary.
Bibliography.
Index of LISP Primitives Used in this Book.
Index of LISP Definitions.
General Index.
商品描述(中文翻譯)
目錄
(注意: 每章結束時都有一個摘要。)
目錄.
1. 理解符號操作。
Lisp幫助使計算機智能化。
Lisp促進生產力並促進教育。
Lisp是學習符號操作的正確語言。
CommonLisp是正確的Lisp語言學習選擇。
謹防虛假神話。
參考文獻。
2. 基本的Lisp原始操作。
Lisp的程序和數據是符號表達式。
列表就像碗一樣。
引用停止評估。
一些老手使用CAR和CDR。
SETF將值分配給符號。
SETF接受多個符號-值對。
某些原子的評估結果是它們自己。
CONS、APPEND和LIST不會改變符號的值。
NTHCDR、BUTLAST和LAST縮短列表。
LENGTH和REVERSE作用於頂層元素。
ASSOC尋找索引子列表。
Lisp提供整數、比例和浮點數等等。
一些用於數字的原始操作完善了基本技能。
3. 程序定義和綁定。
參數變量值由虛擬圍欄隔離。
特殊變量值不受虛擬圍欄隔離。
程序將參數與參數進行匹配。
LET形式產生嵌套的圍欄。
LET形式並行評估初始值形式。
LET*形式按順序評估初始值形式。
漸進包裝和註釋轉換有助於定義新的程序。
4. 斷言和條件語句。
MEMBER測試列表成員資格。
關鍵字參數修改行為。