Lisp, 3/e (Paperback)
暫譯: Lisp 第三版 (平裝本)
Patrick Winston, Berthold Horn
- 出版商: Addison Wesley
- 出版日期: 2019-07-12
- 售價: $2,210
- 貴賓價: 9.5 折 $2,100
- 語言: 英文
- 頁數: 640
- 裝訂: Paperback
- ISBN: 0201083191
- ISBN-13: 9780201083194
-
相關分類:
Functional-programming
已絕版
買這商品的人也買了...
-
$1,127Artificial Intelligence: A New Synthesis (Paperback) -
Effective awk Programming, 3/e$1,890$1,796 -
$399AI Application Programming (Paperback) -
Practical Common Lisp$3,800$3,610 -
Excel 2003 實力養成暨評量解題秘笈$150$128 -
Microsoft Visual C# 2008 精研講座$650$514 -
SQL 語法範例辭典$550$468 -
Compilers: Principles, Techniques, and Tools, 2/e (IE-Paperback)$1,200$1,176 -
C++ Primer, 4/e (中文版)$990$891 -
現代嵌入式系統開發專案實務－菜鳥成長日誌與專案經理的私房菜$600$480 -
最新 PHP + MySQL + AJAX 網頁程式設計$650$553 -
解密 SEO：如何讓網站排名第一$480$408 -
Google API 開發詳解－Google Maps 與 Google Earth 雙劍合壁$580$458 -
Google Android SDK 開發範例大全$750$593 -
jQuery 開發實戰 (Learning jQuery 1.3)$520$411 -
Windows Device Driver Programming 驅動程式設計$650$553 -
Google 應用服務引擎開發實戰$490$387 -
Facebook 與 funP 應用程式設計$520$343 -
Linux 指令範例速查手冊$450$383 -
Web Layout 設計眼－高品質的網頁設計$420$357 -
iPhone SDK 3 Programming 應用程式開發$420$328 -
Tapworthy：打造完美的 iPhone 應用程式$580$458 -
王者歸來－HTML5 與 CSS 3 權威指南$580$493 -
Android 初學特訓班 (適用 Android 4.X~2.X 手機與平板電腦全面啟動)$480$408 -
Beginning Android 4 Games Development (Paperback)$1,620$1,539
相關主題
商品描述
Table Of Contents
(NOTE: Each chapter ends with a Summary.)
TABLE OF CONTENTS.
1. Understanding Symbol Manipulation.
Symbol Manipulation Is Like Working with Words and Sentences.
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.
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 Means Symbol Manipulation.
Lisp Procedures and Data Are Symbolic Expressions.
Lists Are Like Bowls.
Quoting Stops Evaluation.
Certain Atoms Evaluate to Themselves.
Lisp Offers Integers, Ratios, and Floating-Point Numbers, among Others.
A Few Primitives for Numbers Round Out a Basic Repertoire.
Lisp Procedures and Data Are Symbolic Expressions.
Lists Are Like Bowls.
FIRST and REST Take Lists Apart.
Quoting Stops Evaluation.
Some Old Timers Use CARs and CDRs.
SETF Assigns Values to Symbols.
SETF Accepts Multiple Symbol-Value Pairs.
SETF Assigns Values to Symbols.
SETF Accepts Multiple Symbol-Value Pairs.
Certain Atoms Evaluate to Themselves.
CONS, APPEND and LIST Construct Lists.
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.
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.
DEFUN is Lisp's Procedure-Definition Primitive.
Parameter Variable Values Are Isolated by Virtual Fences.
Special Variable Values Are Not Isolated by Virtual Fences.
Procedures Match Parameters to Arguments.
Progressive Envelopment and Comment Translation Help Define New Procedures.
Parameter Variable Values Are Isolated by Virtual Fences.
Special Variable Values Are Not Isolated by Virtual Fences.
Procedures Match Parameters to Arguments.
LET Forms Bind Parameters to Initial Values.
LET Forms Produce Nested Fences.
LET Forms Evaluate Initial-Value Forms in Parallel.
LET* Forms Evaluate Initial-Value Forms Sequentially.
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.
A Predicate Is a Procedure That Returns True or False.
Keyword Arguments Modify Behavior.
There Are Many Number Predicates.
Problem Reduction Helps Define New Procedures.
EQUAL, EQ, EQL, and = Are Equality Predicates.
MEMBER Tests for List Membership.
MEMBER Tests for List Membership.
Keyword Arguments Modify Behavior.
LISTP, ATOM, NUMBERP, and SYMBOLP Are Data-Type Predicates.
NIL Is Equivalent to the Empty List.
NULL and ENDP Are Empty-List Predicates.
NIL Is Equivalent to the Empty List.
NULL and ENDP Are Empty-List Predicates.
There Are Many Number Predicates.
AND, OR, and NOT Enable Elaborate TestingPredicates Help IF, WHEN, and UNLESS Choose among Alternatives.
Predicates Help COND Choose among Alternatives.
CASE Is Still Another Conditional.
Conditionals Enable DEFUN To Do Much More.
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.
Procedure Abstraction Hides Details Behind Abstraction Boundaries.
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.
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 Details Stifle Progress.
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.
References.
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.
MAPCAR Simplifies Transforming Operations.
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.
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.
DOTIMES Supports Iteration on Numbers.
DOLIST Supports Iteration on Lists.
DO Is More General than DOLIST and DOTIMES.
LOOP Never Stops, Almost.
PROG1 and PROGN Handle Sequences Explicitly.
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.
Programs and Data Reside in Files.
File Specifications Tend to Have Baroque Forms.
Emacs Is a Particularly Powerful Lisp Editor.
References.
File Specifications Tend to Have Baroque Forms.
ED Takes You to an Editor.
Emacs Is a Particularly Powerful Lisp Editor.
COMPILE-FILE Compiles Files.
LOAD Causes Lisp To Read from Files.
LOAD Causes Lisp To Read from Files.
References.
9. Printing and Reading.
PRINT and READ Facilitate Simple 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.
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.
Special Primitives Manipulate Strings and Characters.
READ-LINE and READ-CHAR Read Strings and Characters.
10. Rules for Good Programming and Tools for Debugging.
Following Rules of Good Programming Practice Helps You To Avoid Bugs.
Big Programs Require Abstraction and Modularity.
Debugging Is Implementation Specific.
References.
Big Programs Require Abstraction and Modularity.
Most Programmers use TRACE, STEP, and BREAK with Varying Frequency.
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.
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.
Each Way of Storing Data Has Constructors, Readers, and Writers.
Properties Enable Storage in Symbolically Indexed Places.
Arrays Enable Storage in Numerically Indexed Places.
Properties Enable Storage in Symbolically Indexed Places.
GET and SETF are the Custodians of Properties.
Arrays Enable Storage in Numerically Indexed Places.
MAKE-ARRAY, AREF, and SETF are the Custodians of Arrays.
12. Macros and Backquote.
Macros Translate and Then Evaluate.
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.
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 Facilitate Data Abstraction.
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.
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.
DESCRIBE Prints Descriptions.
DEFSTRUCTs Deserve Their Own File.
DEFSTRUCTs Deserve Their Own File.
14. Classes and Generic Functions.
What to Do Depends on What You Do it to.
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.
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.
Bindings Could Be Kept on a Record of Calls.
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.
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.
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.
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.
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.
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.
Some Variables Are Declared To Be Special Forevermore.
Special-Variable Bindings Are Actually Kept on a Stack.
DEFVAR Can Assign as Well as Declare.
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.
CONS Builds New Lists by Depositing Pointers in Free Boxes.
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.
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.
MARK Places Marks on Useful Chunks.
SWEEP Collects Unmarked Chunks.
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.
MICRO-EVAL and MICRO-APPLY Work Together To Evaluate Forms.
Traces Show How MICRO-EVAL and MICRO-APPLY Work Together.
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.
MATCH Keeps Variable Bindings on an Association List.
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 First Pass Concentrates on MATCH and the Binding Stream.
Our Second Pass Concentrates on the Procedures that Surround MATCH.
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 First Pass Concentrates on MATCH, UNIFY, and the Binding Stream.
Our Second Pass Concentrates on the Procedures that Surround MATCH and UNIFY.
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。
小心虛假的神話。
參考文獻。
Lisp 有助於讓計算機變得智能。
Lisp 促進生產力並促進教育。
Lisp 是學習符號操作的正確語言。
CommonLisp 是學習的正確 Lisp。
小心虛假的神話。
參考文獻。
2. 基本 Lisp 原語。
Lisp 意味著符號操作。
Lisp 程序和數據是符號表達式。
列表就像碗。
引用停止評估。
某些原子評估為其自身。
Lisp 提供整數、比率和浮點數等。
一些數字的原語補充了基本的語彙。
Lisp 程序和數據是符號表達式。
列表就像碗。
FIRST 和 REST 拆分列表。
引用停止評估。
一些老手使用 CAR 和 CDR。
SETF 將值分配給符號。
SETF 接受多個符號-值對。
SETF 將值分配給符號。
SETF 接受多個符號-值對。
某些原子評估為其自身。
CONS、APPEND 和 LIST 構建列表。
CONS、APPEND 和 LIST 不會改變符號值。
NTHCDR、BUTLAST 和 LAST 縮短列表。
LENGTH 和 REVERSE 在頂層元素上工作。
ASSOC 查找索引子列表。
CONS、APPEND 和 LIST 不會改變符號值。
NTHCDR、BUTLAST 和 LAST 縮短列表。
LENGTH 和 REVERSE 在頂層元素上工作。
ASSOC 查找索引子列表。
Lisp 提供整數、比率和浮點數等。
一些數字的原語補充了基本的語彙。
3. 程序定義和綁定。
DEFUN 是 Lisp 的程序定義原語。
參數變量值由虛擬圍欄隔離。
特殊變量值不受虛擬圍欄的隔離。
程序將參數與實際參數匹配。
漸進包裝和註解翻譯有助於定義新程序。
參數變量值由虛擬圍欄隔離。
特殊變量值不受虛擬圍欄的隔離。
程序將參數與實際參數匹配。
LET 表達式將參數綁定到初始值。
LET 表達式產生嵌套圍欄。
LET 表達式並行評估初始值表達式。
LET* 表達式按順序評估初始值表達式。
LET 表達式產生嵌套圍欄。
LET 表達式並行評估初始值表達式。
LET* 表達式按順序評估初始值表達式。
漸進包裝和註解翻譯有助於定義新程序。
4. 謂詞和條件語句。
謂詞是一種返回真或假的程序。
關鍵字參數修改行為。
有許多數字謂詞。
問題簡化有助於定義新程序。
EQUAL、EQ、EQL 和 = 是相等謂詞。
MEMBER 測試列表成員資格。
MEMBER 測試列表成員資格。
關鍵字參數修改行為。
LISTP、ATOM、NUMBERP 和 SYMBOLP 是數據類型謂詞。
NIL 等同於空列表。
NULL 和 ENDP 是空列表謂詞。
NIL 等同於空列表。
NULL 和 ENDP 是空列表謂詞。
有許多數字謂詞。
AND、OR 和 NOT 使得複雜測試成為可能，謂詞幫助 IF、WHEN 和 UNLESS 在選擇替代方案。
謂詞幫助 COND 在選擇替代方案。
CASE 是另一種條件語句。
條件語句使 DEFUN 能夠做更多事情。
謂詞幫助 COND 在選擇替代方案。
CASE 是另一種條件語句。
條件語句使 DEFUN 能夠做更多事情。
問題簡化有助於定義新程序。
5. 程序抽象和遞歸。
程序抽象隱藏了抽象邊界後的細節。
遞歸允許程序使用自身。
遞歸可以是高效的。
遞歸可以用來分析嵌套表達式。
可選參數消除了對許多輔助參數的需求。
高級程序員使用 Rest、Key 和 Aux 參數。
只有少數 Lisp 原語是實際上必要的。
參考文獻。
遞歸允許程序使用自身。
遞歸可以是高效的。
遞歸可以用來分析嵌套表達式。
可選參數消除了對許多輔助參數的需求。
高級程序員使用 Rest、Key 和 Aux 參數。
只有少數 Lisp 原語是實際上必要的。
參考文獻。
6. 數據抽象和映射。
數據細節抑制進步。
數據抽象促進進步。
你應該自由使用讀取器、構造器和寫入器。
轉換和過濾是有用的。
遞歸程序可以進行轉換和過濾。
遞歸程序可以計數和查找。
陳詞濫調體現了重要的編程知識。
參考文獻。
數據抽象促進進步。
你應該自由使用讀取器、構造器和寫入器。
轉換和過濾是有用的。
遞歸程序可以進行轉換和過濾。
遞歸程序可以計數和查找。
陳詞濫調體現了重要的編程知識。
MAPCAR 簡化了轉換操作。
REMOVE-IF 和 REMOVE-IF-NOT 簡化了過濾操作。
COUNT-IF 和 FIND-IF 簡化了計數和查找操作。
FUNCALL 和 APPLY 也接受程序作為參數。
LAMBDA 定義匿名程序。
REMOVE-IF 和 REMOVE-IF-NOT 簡化了過濾操作。
COUNT-IF 和 FIND-IF 簡化了計數和查找操作。
FUNCALL 和 APPLY 也接受程序作為參數。
LAMBDA 定義匿名程序。
參考文獻。
7. 數字和列表的迭代。
DOTIMES 支持對數字的迭代。
DOLIST 支持對列表的迭代。
DO 比 DOLIST 和 DOTIMES 更通用。
LOOP 幾乎不會停止。
PROG1 和 PROGN 明確處理序列。
DOLIST 支持對列表的迭代。
DO 比 DOLIST 和 DOTIMES 更通用。
LOOP 幾乎不會停止。
PROG1 和 PROGN 明確處理序列。
8. 文件編輯、編譯和加載。
程序和數據存儲在文件中。
文件規範往往具有繁瑣的形式。
Emacs 是一個特別強大的 Lisp 編輯器。
參考文獻。
文件規範往往具有繁瑣的形式。
ED 將你帶到編輯器。
Emacs 是一個特別強大的 Lisp 編輯器。
COMPILE-FILE 編譯文件。
LOAD 使 Lisp 從文件中讀取。
LOAD 使 Lisp 從文件中讀取。
參考文獻。
9. 打印和讀取。
PRINT 和 READ 促進簡單的打印和讀取。
FORMAT 使得特殊打印成為可能。
WITH-OPEN-FILE 使得從文件中讀取成為可能。
READ 表達式中的可選參數指定文件結尾的處理。
WITH-OPEN-FILE 使得打印到文件成為可能。
READ 不會評估表達式，但 EVAL 會評估兩次。
READ-LINE 和 READ-CHAR 讀取字符串和字符。
FORMAT 使得特殊打印成為可能。
WITH-OPEN-FILE 使得從文件中讀取成為可能。
READ 表達式中的可選參數指定文件結尾的處理。
WITH-OPEN-FILE 使得打印到文件成為可能。
READ 不會評估表達式，但 EVAL 會評估兩次。
特殊原語操作字符串和字符。
READ-LINE 和 READ-CHAR 讀取字符串和字符。
10. 良好編程的規則和調試工具。
遵循良好編程實踐的規則有助於避免錯誤。
大型程序需要抽象和模塊化。
調試是實現特定的。
參考文獻。
大型程序需要抽象和模塊化。
大多數程序員以不同的頻率使用 TRACE、STEP 和 BREAK。
TRACE 使程序打印其參數和值。
STEP 使程序逐步執行。
BREAK 停止評估，以便你可以評估表達式。
TIME、DESCRIBE 和 DRIBBLE 也很有幫助。
TRACE 使程序打印其參數和值。
STEP 使程序逐步執行。
BREAK 停止評估，以便你可以評估表達式。
TIME、DESCRIBE 和 DRIBBLE 也很有幫助。
調試是實現特定的。
參考文獻。
11. 屬性和數組。
每種存儲數據的方式都有構造器、讀取器和寫入器。
屬性使得在符號索引的位置存儲成為可能。
數組使得在數字索引的位置存儲成為可能。
屬性使得在符號索引的位置存儲成為可能。
GET 和 SETF 是屬性的管理者。
數組使得在數字索引的位置存儲成為可能。
MAKE-ARRAY、AREF 和 SETF 是數組的管理者。
12. 宏和反引號。
宏翻譯然後評估。
反引號機制簡化了模板填充。
反引號機制簡化了宏的編寫。
可選、Rest 和 Key 參數使得更強大的宏成為可能。
宏應該有自己的文件。
反引號機制簡化了模板填充。
反引號機制簡化了宏的編寫。
可選、Rest 和 Key 參數使得更強大的宏成為可能。
宏應該有自己的文件。
13. 結構。
結構類型促進數據抽象。
結構類型使得在程序索引的位置存儲成為可能。
個別結構類型是新的數據類型。
一個結構類型可以包含另一個結構的字段。
結構類型是大型系統的重要組成部分。
```
結構類型使得在程序索引的位置存儲成為可能。
個別結構類型是新的數據類型。
一個結構類型可以包含另一個結構的字段。
結構類型是大型系統的重要組成部分。
DESCRIBE 打印描述。
DEFSTRUCT 應該有自己的文件。
DEFSTRUCT 應該有自己的文件。
```
