Weitz Common Lisp Recipes

A Problem-Solution Approach
1. ed
ISBN: 978-1-4842-1176-2
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 755 Seiten

This book is a collection of solutions to problems and answers to questions you are likely to encounter when writing real-world applications in Common Lisp. Written by an author who has used Common Lisp in many successful commercial projects over more than a decade, this book covers areas as diverse as web programming, databases, graphical user interfaces, integration with other programming languages, multi-threading, and mobile devices as well as debugging techniques and optimization, to name just a few. It is also the first Common Lisp book to tackle such advanced topics as environment access, logical pathnames, Gray streams, delivery of executables, pretty printing, setf expansions, or changing the syntax of Common Lisp.
The book is organized around specific problems or questions each followed by ready-to-use example solutions and clear explanations of the concepts involved, plus pointers to alternatives and more information. Each recipe can be read independently of the others and thus the book will earn a special place on your bookshelf as a reference work you always want to have within reach.
Common Lisp Recipes is aimed at programmers who are already familiar with Common Lisp to a certain extent but do not yet have the experience you typically only get from years of hacking in a specific computer language. It is written in a style that mixes hands-on no-frills pragmatism with precise information and prudent mentorship. 
If you feel attracted to Common Lisp's mix of breathtaking features and down-to-earth utilitarianism, you'll also like this book.

Edmund Weitz is well-known in the Common Lisp community for his open-source libraries and for being one of the organizers of the European Common Lisp Meeting. He has a Ph.D. in mathematics and has been a free-lance Common Lisp consultant for clients in the US, Europe, and Asia since 2002. He now works as a professor for math and computer science at the University of Applied Sciences in Hamburg, Germany.

Autoren/Hrsg.

Weitz, Edmund

Inhaltsverzeichnis

1;Table of Contents;5
2;About the Author;16
3;About the Technical Reviewer;17
4;Preface;18
4.1;Who This Book Is For;18
4.1.1;Who This Book Is (Probably) Not For;19
4.1.1.1;How to Read This Book;19
4.1.1.2;What's In and What Not;20
4.1.1.3;The HyperSpec;21
4.1.1.4;Which Implementation;21
4.1.1.5;Source Code;22
4.1.1.6;The Index;22
4.1.1.7;Typographical Conventions;22
4.1.1.8;Acknowledgements;23
5;1. Symbols and Packages;25
5.1;1-1. Understanding the Role of Packages and the Symbol Nomenclature;25
5.2;1-2. Making Unique Symbols;29
5.3;1-3. Making Symbols Inaccessible;33
5.3.1;How Can We Fix This?;35
5.4;1-4. Avoiding Name Conflicts;36
5.4.1;When Name Conflicts Do Not Occur;39
5.5;1-5. Using Symbols As Stand-Ins for Arbitrary Forms;39
5.6;1-6. Searching for Symbols by Name;41
5.7;1-7. Iterating Through All Symbols of a Package;43
5.7.1;What To Do If You Don't Like LOOP;44
5.8;1-8. Understanding Common Lisp's Case (In)Sensitivity;45
5.8.1;Style Hint: Don't Use CamelCase!;49
5.9;1-9. Using Symbols As String Substitutes;50
5.9.1;So, What Should You Use?;51
5.10;1-10. "Overloading" of Standard Common Lisp Operators;52
6;2. Conses, Lists, and Trees;55
6.1;2-1. Understanding Conses;55
6.1.1;List Access;58
6.1.1.1;Testing Whether Something Is a Cons or a List;59
6.2;2-2. Creating Lists;61
6.2.1;Converting Vectors to Lists;62
6.3;2-3. Transposing a Matrix;63
6.4;2-4. Using List Interpolation;64
6.5;2-5. Adding Objects to the End of a List;66
6.5.1;The Tail Wagging the List;68
6.6;2-6. "Splicing" into a List;69
6.7;2-7. Detecting Shared Structure in Lists;73
6.7.1;Isolating the Non-Shared Part;75
6.8;2-8. Working with Trees;75
6.8.1;More Complicated Trees;78
6.8.1.1;Common Lisp's Standard Tree Functions;79
6.9;2-9. Working with Stacks;79
6.10;2-10. Implementing a Queue;80
6.11;2-11. Destructuring and Pattern Matching;82
7;3. Strings and Characters;84
7.1;3-1. Getting the ASCII Code of a Character;84
7.1.1;The Other Way Around;86
7.1.1.1;The Limit;86
7.2;3-2. Naming Characters;86
7.3;3-3. Using Different Character Encodings;88
7.4;3-4. Comparing Strings or Characters;90
7.4.1;Internationalization;93
7.5;3-5. Escaping Characters in String Literals and Variable Interpolation;94
7.5.1;Is It Still a Literal?;95
7.6;3-6. Controlling Case;95
7.6.1;What About Unicode?;97
7.7;3-7. Accessing or Modifying a Substring;98
7.8;3-8. Finding a Character or a Substring Within a String;100
7.9;3-9. Trimming Strings;100
7.10;3-10. Processing a String One Character at a Time;102
7.11;3-11. Joining Strings;104
7.12;3-12. Reading CSV Data;106
8;4. Numbers and Math;109
8.1;4-1. Using Arbitrarily Large Integers;109
8.2;4-2. Understanding Fixnums;111
8.3;4-3. Performing Modular Arithmetic;114
8.3.1;Efficiency Considerations;115
8.4;4-4. Switching Bases;116
8.5;4-5. Performing Exact Arithmetic with Rational Numbers;118
8.5.1;Various Ways of Converting Numbers to Integers;120
8.5.1.1;How Not to Use FLOOR and Friends;121
8.5.1.2;Converting Floating-Point Numbers to Rationals and Vice Versa;121
8.5.1.3;Mixing Rationals and Floats;123
8.6;4-6. Controlling the Default Float Format;124
8.7;4-7. Employing Arbitrary Precision Floats;126
8.8;4-8. Working with Complex Numbers;128
8.9;4-9. Parsing Numbers;131
8.10;4-10. Testing Whether Two Numbers Are Equal;133
8.10.1;Don't Ever Use EQ with Numbers!;134
8.11;4-11. Computing Angles Correctly;135
8.12;4-12. Calculating Exact Square Roots;137
9;5. Arrays and Vectors;138
9.1;5-1. Working with Multiple Dimensions;138
9.2;5-2. Understanding Vectors and Simple Arrays;140
9.3;5-3. Obtaining the Size of an Array;141
9.4;5-4. Providing Initial Contents;142
9.4.1;A Warning About Identical Objects;143
9.5;5-5. Treating Arrays As Vectors;144
9.6;5-6. Making the Length of Vectors Flexible;146
9.7;5-7. Adjusting Arrays;148
9.8;5-8. Using an Array As a "Window" into Another Array;150
9.9;5-9. Restricting the Element Type of an Array;152
9.9.1;Upgrading Element Types;154
9.10;5-10. Copying an Array;155
9.10.1;A Warning About Object Identity;156
10;6. Hash Tables, Maps, and Sets;157
10.1;6-1. Understanding the Basics of Hash Tables;157
10.1.1;Why Does GETHASH Return Two Values?;159
10.1.1.1;How Many Entries Does the Hash Table Have?;160
10.2;6-2. Providing Default Values For Hash Table Lookups;160
10.3;6-3. Removing Hash Table Entries;162
10.4;6-4. Iterating Through a Hash Table;163
10.4.1;Don't Rely on Any Order!;166
10.4.1.1;Don't Modify While You're Iterating!;167
10.4.1.2;Can't This Be More Concise, Please?;167
10.5;6-5. Understanding Hash Table Tests and Defining Your Own;168
10.5.1;What Is SXHASH For?;172
10.6;6-6. Controlling Hash Table Growth;172
10.7;6-7. Getting Rid of Hash Table Entries Automatically;175
10.8;6-8. Representing Maps As Association Lists;178
10.8.1;Combining Lookup and Manipulation;181
10.8.1.1;Why Would Anybody Prefer Alists over Hash Tables?;182
10.9;6-9. Representing Maps As Property Lists;183
10.9.1;When to Prefer Plists over Alists;185
10.9.1.1;The Plist of a Symbol;186
10.10;6-10. Working with Sets;186
10.10.1;Representing Sets As Hash Tables;189
10.10.1.1;Representing Sets As Bit Patterns;189
11;7. Sequences and Iteration;191
11.1;7-1. Filtering a Sequence;191
11.2;7-2. Searching a Sequence;192
11.3;7-3. Sorting and Merging Sequences;195
11.4;7-4. Mixing Different Sequence Types;197
11.5;7-5. Re-Using a Part of a Sequence;197
11.6;7-6. Repeating Some Values Cyclically;199
11.6.1;Alternatives;201
11.7;7-7. Counting Down;202
11.8;7-8. Iterating over "Chunks" of a List;204
11.9;7-9. Closing over Iteration Variables;206
11.10;7-10. "Extending" Short Sequences in Iterations;207
11.11;7-11. Breaking out of LOOP;208
11.12;7-12. Making Sense of the MAP… Zoo;211
11.12.1;The Sequence Variants;214
11.13;7-13. Defining Your Own Sequence Types;214
11.14;7-14. Iterating with iterate;216
11.15;7-15. Iterating with series;220
11.15.1;What the Example Does;221
12;8. The Lisp Reader;223
12.1;8-1. Employing the Lisp Reader for Your Own Code;223
12.1.1;Why READ Is Potentially Dangerous;225
12.1.1.1;What READ Doesn't Do;225
12.1.1.2;The Optional Arguments to READ;226
12.1.1.3;Go Wild!;226
12.2;8-2. Troubleshooting Literal Object Notation;226
12.2.1;This Also Applies to Strings!;228
12.3;8-3. Evaluating Forms at Read Time;228
12.3.1;What to Look Out For;230
12.3.1.1;Alternatives;230
12.4;8-4. Embedding Literal Arrays into Your Code;231
12.4.1;The Usual Warning;232
12.5;8-5. Understanding the Different Ways to Refer to a Function;233
12.6;8-6. Repeating Something You Already Typed;234
12.6.1;They Don't Only Look Identical, They Are Identical!;236
12.7;8-7. Safely Experimenting with Readtables;236
12.7.1;Temporarily Switching to Standard IO Syntax;238
12.8;8-8. Changing the Syntax Type of a Character;239
12.8.1;The Six Syntax Types;240
12.8.1.1;How to Actually Change the Syntax Type;242
12.8.1.2;Some Things Never Change;242
12.9;8-9. Creating Your Own Reader Macros;243
12.9.1;What Reader Macro Functions Do;244
12.10;8-10. Working with Dispatching Macro Characters;246
12.11;8-11. Preserving Whitespace;248
13;9. Printing;250
13.1;9-1. Using the Printing Primitives;250
13.1.1;Printing Objects So That They Can Be Read Back in Again;254
13.1.1.1;Shortcuts;255
13.2;9-2. Printing to and into Strings;256
13.3;9-3. Printing NIL As a List;258
13.4;9-4. Extending FORMAT Control Strings Over More Than One Line;259
13.5;9-5. Using Functions As FORMAT Controls;260
13.6;9-6. Creating Your Own FORMAT Directives;262
13.7;9-7. Recursive Processing of FORMAT Controls;264
13.8;9-8. Controlling How Your Own Objects Are Printed;266
13.9;9-9. Controlling the Pretty Printer;268
13.10;9-10. Printing Long Lists;272
13.11;9-11. Pretty-Printing Compound Objects;276
13.11.1;Using the Pretty Printer from FORMAT;279
13.12;9-12. Modifying the Pretty Printer;281
14;10. Evaluation, Compilation, Control Flow;283
14.1;10-1. Comparing Arbitrary Lisp Objects;283
14.1.1;Comparing State;284
14.1.1.1;Constants;287
14.2;10-2.Using Constant Variables as Keys in CASE Macros;287
14.3;10-3. Using Arbitrary Variable Names for Keyword Parameters;289
14.3.1;Keyword Names Don't Have to Be Keywords;290
14.3.1.1;Keyword Dames Don't Have to Be Constant;291
14.4;10-4. Creating ``Static Local Variables,'' Like in C;291
14.5;10-5.``Preponing'' the Computation of Values;293
14.6;10-6. Modifying the Behavior of Functions You Don't Have the Source Of;296
14.7;10-7. Swapping the Values of Variables (or Places);298
14.8;10-8. Creating Your Own Update Forms for ``Places'';301
14.8.1;Using DEFSETF;303
14.8.1.1;Using DEFINE-SETF-EXPANDER;304
14.8.1.2;So, Which One Do I Use?;309
14.8.1.3;Using DEFINE-MODIFY-MACRO;309
14.8.1.4;Multiple-Valued Places;311
14.9;10-9. Working with Environments;312
14.10;10-10. Commenting Out Parts of Your Code;317
14.10.1;Some Notes About ; and #|;320
14.10.1.1;How ;, #|, and Others Are Implemented;320
15;11. Concurrency;321
15.1;11-1. Managing Lisp Processes;322
15.1.1;Escape Hatches;325
15.1.1.1;Threads Are Expensive;326
15.2;11-2. Accessing Shared Resources Concurrently;326
15.2.1;Locks;330
15.2.1.1;Atomic Operations;331
15.2.1.2;More Problems;332
15.3;11-3. Using Special Variables in Concurrent Programs;335
15.3.1;Per-Thread Initial Bindings;337
15.3.1.1;Variables That Are Always Global;337
15.4;11-4. Communicating with Other Threads;338
15.4.1;Alternatives;340
15.5;11-5. Parallelizing Algorithms Without Threads and Locks;340
15.5.1;What the Example Does;343
15.5.1.1;Fine-Tuning;344
15.5.1.2;Ptrees;344
15.5.1.3;Alternatives;348
15.6;11-6. Determining the Number of Cores;348
16;12. Error Handling and Avoidance;350
16.1;12-1. Checking Types at Run Time;350
16.1.1;Alternatives;352
16.2;12-2. Adding Assertions to Your Code;353
16.2.1;Disabling Assertions in ``Production Code'';355
16.3;12-3. Defining Your Own Conditions;355
16.3.1;How Conditions Are Printed;357
16.4;12-4. Signaling a Condition;358
16.4.1;Condition Designators;360
16.5;12-5. Handling Conditions;361
16.5.1;Ignoring Errors;366
16.6;12-6. Providing and Using Restarts;367
16.6.1;Visible Restarts;371
16.6.1.1;Predefined Restarts;372
16.7;12-7. Getting Rid of Warning Messages;373
16.8;12-8. Protecting Code from Non-Local Exits;374
16.8.1;``WITH-'' Macros;377
17;13. Objects, Classes, Types;378
17.1;13-1. Defining Types;378
17.1.1;Compound Type Specifiers;380
17.1.1.1;Derived Types;382
17.2;13-2. Using Classes As Types;383
17.3;13-3. Writing Methods for Built-In Classes;384
17.4;13-4. Providing Constructors for Your Classes;386
17.5;13-5. Marking Slots As ``Private'';389
17.6;13-6. Changing the Argument Precedence Order;391
17.7;13-7. Automatically Initializing Slots on First Usage;393
17.8;13-8. Changing and Redefining Classes on the Fly;394
17.8.1;Objects Changing Their Class;397
17.8.1.1;Redefining Classes;398
17.9;13-9. Making Your Objects Externalizable;400
17.10;13-10. Using and Defining Non-Standard Method Combinations;402
17.10.1;Rolling Your Own;405
17.10.1.1;Arbitrarily Complex Method Combinations;406
17.11;13-11. Extending and Modifying CLOS;408
17.11.1;What the example does;410
18;14. I/O: Streams and Files;413
18.1;14-1. Redirecting Streams;413
18.1.1;Other Ways to Do It;414
18.1.1.1;Synonym Streams;415
18.2;14-2. Flushing an Output Stream;416
18.3;14-3. Determining the Size of a File;417
18.4;14-4. Reading a Whole File at Once;418
18.4.1;Alternatives;420
18.5;14-5. Sending Data to Two Streams in Parallel;420
18.5.1;Synonym Streams;422
18.6;14-6. Sending Data to ``/dev/null'';423
18.7;14-7. Pretending a String Is a Stream;424
18.7.1;More Details;426
18.8;14-8. Concatenating Streams;427
18.9;14-9. Processing Text Files Line by Line;428
18.9.1;What Happens at the End of a Line?;429
18.9.1.1;What Happens at the End of the File?;430
18.10;14-10. Working with Binary Data;431
18.10.1;Reading or Writing Several Bytes at Once;432
18.10.1.1;You Might Get Bigger Chunks Than You Asked For;433
18.11;14-11. Reading ``Foreign'' Binary Data;434
18.11.1;Floating-Point Values;437
18.12;14-12. Using Random Access I/O;438
18.12.1;Different Characters May Have Different Lengths;440
18.13;14-13. Serializing Lisp Objects;441
18.13.1;Shared Structure;443
18.13.1.1;Is It Readable?;444
18.13.1.2;Can This Be Done Faster, Please?;445
18.13.1.3;What About JSON or Other Formats?;446
18.14;14-14. Customizing Stream Behavior;446
19;15. Pathnames, Files, Directories;450
19.1;15-1. Getting and Setting the Current Directory;450
19.1.1;Shortcuts and Deviations;452
19.2;15-2. Testing Whether a File Exists;452
19.2.1;What About Directories?;454
19.3;15-3. Creating a Directory;454
19.3.1;Implementation-Specific Alternatives;456
19.3.1.1;What Might Go Wrong;456
19.4;15-4. Finding Files Matching a Pattern;457
19.5;15-5. Splitting a Filename into its Component Parts;460
19.6;15-6. Renaming a File;462
19.6.1;Implementation-Specific Alternatives;464
19.6.1.1;Don't Expect ``Move'' Behavior!;464
19.7;15-7. Deleting a File;465
19.7.1;What Does ``Success'' Mean Anyway?;466
19.8;15-8. Deleting a Directory;467
19.9;15-9. Copying a File;468
19.10;15-10. Processing the Contents of a Directory Recursively;469
19.10.1;The CL-FAD Library;470
19.11;15-11. Getting the Pathname a Stream Is Associated With;471
19.12;15-12. Dealing with Symbolic Links;472
19.12.1;What If I Want the Symlinks?;474
19.13;15-13. Navigating a Directory Tree;474
19.14;15-14. Figuring Out (Source) File Locations Programmatically;476
19.15;15-15. Understanding Logical Pathnames;478
19.15.1;What Exactly Are Logical Pathnames?;482
19.15.1.1;So, Maybe Logical Pathnames Aren't Totally Useless…;482
20;16. Developing and Debugging;484
20.1;16-1. Embracing Lisp's Image-Based Development Style;484
20.1.1;The Role of the Source Code;486
20.2;16-2. Deciding Which IDE to Use;486
20.2.1;A Brief History of Emacs (As Seen from Lisp);489
20.2.1.1;Alternatives (?);490
20.3;16-3. Debugging with the Debugger;490
20.3.1;Entering the Debugger Intentionally;493
20.3.1.1;Without SLIME;494
20.3.1.2;Logging Backtraces;495
20.4;16-4. Tracing Functions;496
20.4.1;Graphical Tracing;498
20.5;16-5. Stepping Through Your Code;499
20.6;16-6. Acquiring Information About Functions, Macros, and Variables;501
20.6.1;Accessing the HyperSpec;503
20.6.1.1;Cross-Reference Information;504
20.7;16-7. Inspecting and Modifying (Compound) Objects;504
20.7.1;The SLIME Inspector;507
20.8;16-8. Browsing Your Lisp Image;507
20.8.1;Alternatives;508
20.9;16-9. ``Undoing'' Definitions;509
20.10;16-10. Distinguishing Your IDE's Streams;512
20.11;16-11. Utilizing the REPL's Memory;514
20.11.1;IDE History Features;515
20.12;16-12. Recording Your Work;516
21;17. Optimization;518
21.1;17-1. Understanding the Importance of the Right Algorithms;519
21.2;17-2. Deciding If and Where to Optimize;520
21.2.1;Instrumentation;523
21.2.1.1;Statistical Profiling;525
21.2.1.2;Some Things Cannot Be Profiled;527
21.2.1.3;Where to Go From Here;527
21.2.1.4;A Warning About Empirical Data;528
21.2.1.5;What Does TIME Do?;528
21.2.1.6;CPUs Can Deceive You;528
21.3;17-3. Asking the Compiler to Optimize;530
21.3.1;Implementation-Defined Optimize Qualities;532
21.3.1.1;Can I Have This Global, Please?;532
21.3.1.2;Compilers Aren't Wizards;533
21.4;17-4. Obtaining Optimization Hints from the Compiler;533
21.5;17-5. Helping the Compiler by Providing Type Information;537
21.5.1;Generic Operations;540
21.5.1.1;Boxing;540
21.5.1.2;How to Declare Types;541
21.5.1.3;The Scope of Type Declarations;542
21.5.1.4;Declaring the Return Type of Forms;543
21.5.1.5;Type Inference;543
21.5.1.6;Pitfalls;544
21.6;17-6. Reducing ``Consing'';544
21.6.1;``Consing'' and the Heap;547
21.6.1.1;Reusing Data Structures;548
21.6.1.2;Destructive Functions;549
21.6.1.3;``Hidden'' Consing;550
21.6.1.4;``Tuning'' the Garbage Collector;551
21.7;17-7. Using the Stack Instead of the Heap;551
21.7.1;Multiple Values;555
21.8;17-8. Optimizing Recursive Functions;557
21.9;17-9. Helping the Compiler with Alternative Implementation Strategies;559
21.10;17-10. Avoiding Repeated Computations;562
21.11;17-11. Avoiding Function Calls;564
21.11.1;Alternatives That Aren't Really Alternatives;568
21.11.1.1;The NOTINLINE Declaration and Compiler Macros;568
21.12;17-12. Utilizing the Disassembler;568
21.13;17-13. Switching to Machine Code;571
21.13.1;Inline Assembly Code;572
21.14;17-14. Optimizing Array Access;573
21.15;17-15. Comparing Different Implementations;575
22;18. Libraries;577
22.1;18-1. Organizing Your Code;577
22.1.1;Components;578
22.1.1.1;Dependencies;579
22.1.1.2;How Does ASDF Find System Definitions?;581
22.1.1.3;Additional Information;582
22.1.1.4;What About the Names?;582
22.1.1.5;Advanced Usage of ASDF;582
22.2;18-2. Employing Open Source Libraries;583
22.2.1;Installing Quicklisp;584
22.2.1.1;Using Quicklisp for Your Own Code;585
22.3;18-3. Creating a Project's Skeleton Automatically;585
22.4;18-4. Avoiding Wheel-Reinvention;586
22.5;18-5. Using Libraries to Write Portable Code;588
22.6;18-6. Utilizing Regular Expressions;590
22.6.1;Regex Syntax;591
22.6.1.1;Scanners;592
22.6.1.2;Convenience Features;593
22.6.1.3;Modifying and Dissecting Strings;595
22.6.1.4;More Information;595
22.7;18-7. Obtaining Data via HTTP;595
22.7.1;Parsing HTML;597
22.8;18-8. Creating Dynamic Web Sites with Lisp;598
22.8.1;Generating HTML;602
22.8.1.1;Web Frameworks;603
23;19. Interfacing with Other Languages;604
23.1;19-1. Calling C Functions from Lisp;605
23.1.1;How the FFI Finds and Loads Shared Libraries;607
23.1.1.1;How the FFI Calls C Functions;609
23.1.1.2;How the FFI Converts Between C and Lisp Types;611
23.1.1.3;The ``stdcall Problem'';612
23.2;19-2. Working with C Pointers;613
23.2.1;Typed Pointers;615
23.3;19-3. Accessing and Generating C Arrays;617
23.3.1;Giving C Access to Lisp Arrays;619
23.4;19-4. Handling C Structs and Unions;620
23.4.1;Passing Structs by Value;624
23.5;19-5. Converting Between Lisp and C Strings;624
23.6;19-6. Calling Lisp Functions from C;627
23.7;19-7. Generating FFI Code Automatically;628
23.8;19-8. Embedding C in Common Lisp;630
23.9;19-9. Calling C++ from Lisp;631
23.9.1;Automating the Process;633
23.9.1.1;ECL and Clasp;635
23.10;19-10. Using Java from Lisp;635
23.10.1;Alternatives;638
23.11;19-11. Reading and Writing JSON;641
23.12;19-12. Reading and Writing XML;644
23.13;19-13. Using Prolog from Common Lisp;647
24;20. Graphical User Interfaces;650
24.1;20-1. Using a Web Browser as the GUI for Your Lisp Program;651
24.1.1;What the Example Does;654
24.2;20-2. Building Applications with the ``Lisp Toolkit'';655
24.2.1;What the Example Does;658
24.3;20-3. Creating Common Lisp GUIs Through Java;659
24.3.1;What the Example Does;661
24.3.1.1;A Better Example;661
24.4;20-4. Using CAPI to Build Graphical User Interfaces;665
24.4.1;What the Example Does;668
24.5;20-5. Using Lisp on Mobile Devices;670
24.5.1;Alternatives;673
25;21. Persistence;674
25.1;21-1. Serializing Your Data;675
25.2;21-2. Accessing Relational Databases;677
25.3;21-3.Keeping Your Database in RAM;681
25.4;21-4. Using a Lisp Object Database;685
26;22. The World Outside;689
26.1;22-1. Accessing Environment Variables;689
26.1.1;The Windows Registry and Application-Specific Settings;691
26.2;22-2. Accessing the Command-Line Arguments;691
26.3;22-3. Querying Your Lisp for Information About Its Environment;692
26.4;22-4. Delivering Stand-Alone Executables;694
26.4.1;Delivering Programs with the Commercial Lisps;697
26.5;22-5. Customizing Your Lisp;697
26.5.1;Saving an Image;699
26.6;22-6. Running External Programs;700
26.7;22-7. Embedding Lisp;704
26.7.1;Creating Shared Libraries with LispWorks;706
26.7.1.1;Embedding ABCL in a Java Program;707
26.8;22-8. Measuring Time;708
26.9;22-9. Working with Dates and Times;710
26.9.1;The local-time Library;713
26.10;22-10. Working with the Garbage Collector;715
26.10.1;Finalizers;717
27;Index;720