book

Common Lisp Recipes: A Problem-Solution Approach

Name: Common Lisp Recipes: A Problem-Solution Approach
Author: Edmund Weitz
ISBN: 9781484211762

by Edmund Weitz

January 2016

Intermediate to advanced

772 pages

17h 50m

English

Apress

Read now

Unlock full access

Cover
Title
Copyright
Dedication
Table of Contents
About the Author
About the Technical Reviewer
Preface
Who This Book Is ForWho This Book Is (Probably) Not ForHow to Read This BookWhat’s In and What NotThe HyperSpecWhich ImplementationSource CodeThe IndexTypographical ConventionsAcknowledgements
1. Symbols and Packages
1-1. Understanding the Role of Packages and the Symbol Nomenclature1-2. Making Unique Symbols1-3. Making Symbols InaccessibleHow Can We Fix This?1-4. Avoiding Name ConflictsWhen Name Conflicts Do Not Occur1-5. Using Symbols As Stand-Ins for Arbitrary Forms1-6. Searching for Symbols by Name1-7. Iterating Through All Symbols of a PackageWhat To Do If You Don’t Like LOOP1-8. Understanding COMMON LISP ’s Case (In)SensitivityStyle Hint: Don’t Use CamelCase!1-9. Using Symbols As String SubstitutesSo, What Should You Use?1-10. “Overloading” of Standard COMMON LISP Operators
2. Conses, Lists, and Trees
2-1. Understanding ConsesList AccessTesting Whether Something Is a Cons or a List2-2. Creating ListsConverting Vectors to Lists2-3. Transposing a Matrix2-4. Using List Interpolation2-5. Adding Objects to the End of a ListThe Tail Wagging the List2-6. “Splicing” into a List2-7. Detecting Shared Structure in ListsIsolating the Non-Shared Part2-8. Working with TreesMore Complicated TreesCOMMON LISP ’s Standard Tree Functions2-9. Working with Stacks2-10. Implementing a Queue2-11. Destructuring and Pattern Matching

3. Strings and Characters
3-1. Getting the ASCII Code of a CharacterThe Other Way AroundThe Limit3-2. Naming Characters3-3. Using Different Character Encodings3-4. Comparing Strings or CharactersInternationalization3-5. Escaping Characters in String Literals and Variable InterpolationIs It Still a Literal?3-6. Controlling CaseWhat About Unicode?3-7. Accessing or Modifying a Substring3-8. Finding a Character or a SubstringWithin a String3-9. Trimming Strings3-10. Processing a String One Character at a Time3-11. Joining Strings3-12. Reading CSV Data
4. Numbers and Math
4-1. Using Arbitrarily Large Integers4-2. Understanding Fixnums4-3. Performing Modular ArithmeticEfficiency Considerations4-4. Switching Bases4-5. Performing Exact Arithmetic with Rational NumbersVarious Ways of Converting Numbers to IntegersHow Not to Use FLOOR and FriendsConverting Floating-Point Numbers to Rationals and Vice VersaMixing Rationals and Floats4-6. Controlling the Default Float Format4-7. Employing Arbitrary Precision Floats4-8. Working with Complex Numbers4-9. Parsing Numbers4-10. Testing Whether Two Numbers Are EqualDon’t Ever Use EQ with Numbers!4-11. Computing Angles Correctly4-12. Calculating Exact Square Roots
5. Arrays and Vectors
5-1. Working with Multiple Dimensions5-2. Understanding Vectors and Simple Arrays5-3. Obtaining the Size of an Array5-4. Providing Initial ContentsA Warning About Identical Objects5-5. Treating Arrays As Vectors5-6. Making the Length of Vectors Flexible5-7. Adjusting Arrays5-8. Using an Array As a “Window” into Another Array5-9. Restricting the Element Type of an ArrayUpgrading Element Types5-10. Copying an ArrayA Warning About Object Identity
6. Hash Tables, Maps, and Sets
6-1. Understanding the Basics of Hash TablesWhy Does GETHASH Return Two Values?How Many Entries Does the Hash Table Have?6-2. Providing Default Values For Hash Table Lookups6-3. Removing Hash Table Entries6-4. Iterating Through a Hash TableDon’t Rely on Any Order!Don’t Modify While You’re Iterating!Can’t This Be More Concise, Please?6-5. Understanding Hash Table Tests and Defining Your OwnWhat Is SXHASH For?6-6. Controlling Hash Table Growth6-7. Getting Rid of Hash Table Entries Automatically6-8. Representing Maps As Association ListsCombining Lookup and ManipulationWhy Would Anybody Prefer Alists over Hash Tables?6-9. Representing Maps As Property ListsWhen to Prefer Plists over AlistsThe Plist of a Symbol6-10. Working with SetsRepresenting Sets As Hash TablesRepresenting Sets As Bit Patterns
7. Sequences and Iteration
7-1. Filtering a Sequence7-2. Searching a Sequence7-3. Sorting and Merging Sequences7-4. Mixing Different Sequence Types7-5. Re-Using a Part of a Sequence7-6. Repeating Some Values CyclicallyAlternatives7-7. Counting Down7-8. Iterating over “Chunks” of a List7-9. Closing over Iteration Variables7-10. “Extending” Short Sequences in Iterations7-11. Breaking out of LOOP7-12. Making Sense of the MAP... ZooThe Sequence Variants7-13. Defining Your Own Sequence Types7-14. Iterating with ITERATE7-15. Iterating with SERIESWhat the Example Does
8. The Lisp Reader
8-1. Employing the Lisp Reader for Your Own CodeWhy READ Is Potentially DangerousWhat READ Doesn’t DoThe Optional Arguments to READGo Wild!8-2. Troubleshooting Literal Object NotationThis Also Applies to Strings!8-3. Evaluating Forms at Read TimeWhat to Look Out ForAlternatives8-4. Embedding Literal Arrays into Your CodeThe Usual Warning8-5. Understanding the DifferentWays to Refer to a Function8-6. Repeating Something You Already TypedThey Don’t Only Look Identical, They Are Identical!8-7. Safely Experimenting with ReadtablesTemporarily Switching to Standard IO Syntax8-8. Changing the Syntax Type of a CharacterThe Six Syntax TypesHow to Actually Change the Syntax TypeSome Things Never Change8-9. Creating Your Own Reader MacrosWhat Reader Macro Functions Do8-10. Working with Dispatching Macro Characters8-11. Preserving Whitespace
9. Printing
9-1. Using the Printing PrimitivesPrinting Objects So That They Can Be Read Back in AgainShortcuts9-2. Printing to and into Strings9-3. Printing NIL As a List9-4. Extending FORMAT Control Strings Over More Than One Line9-5. Using Functions As FORMAT Controls9-6. Creating Your Own FORMAT Directives9-7. Recursive Processing of FORMAT Controls9-8. Controlling How Your Own Objects Are Printed9-9. Controlling the Pretty Printer9-10. Printing Long Lists9-11. Pretty-Printing Compound ObjectsUsing the Pretty Printer from FORMAT9-12. Modifying the Pretty Printer
10. Evaluation, Compilation, Control Flow
10-1. Comparing Arbitrary Lisp ObjectsComparing StateConstants10-2. Using Constant Variables as Keys in CASE Macros10-3. Using Arbitrary Variable Names for Keyword ParametersKeyword Names Don’t Have to Be KeywordsKeyword Dames Don’t Have to Be Constant10-4. Creating “Static Local Variables,” Like in C10-5. “Preponing” the Computation of Values10-6. Modifying the Behavior of Functions You Don’t Have the Source Of10-7. Swapping the Values of Variables (or Places)10-8. Creating Your Own Update Forms for “Places”Using DEFSETFUsing DEFINE-SETF-EXPANDERSo, Which One Do I Use?Using DEFINE-MODIFY-MACROMultiple-Valued Places10-9. Working with Environments10-10. Commenting Out Parts of Your CodeSome Notes About ; and #|How ; , #| , and Others Are Implemented
11. Concurrency
11-1. Managing Lisp ProcessesEscape HatchesThreads Are Expensive11-2. Accessing Shared Resources ConcurrentlyLocksAtomic OperationsMore Problems11-3. Using Special Variables in Concurrent ProgramsPer-Thread Initial BindingsVariables That Are Always Global11-4. Communicating with Other ThreadsAlternatives11-5. Parallelizing AlgorithmsWithout Threads and LocksWhat the Example DoesFine-TuningPtreesAlternatives11-6. Determining the Number of Cores
12. Error Handling and Avoidance
12-1. Checking Types at Run TimeAlternatives12-2. Adding Assertions to Your CodeDisabling Assertions in “Production Code”12-3. Defining Your Own ConditionsHow Conditions Are Printed12-4. Signaling a ConditionCondition Designators12-5. Handling ConditionsIgnoring Errors12-6. Providing and Using RestartsVisible RestartsPredefined Restarts12-7. Getting Rid of Warning Messages12-8. Protecting Code from Non-Local Exits“ WITH- ” Macros
13. Objects, Classes, Types
13-1. Defining TypesCompound Type SpecifiersDerived Types13-2. Using Classes As Types13-3. Writing Methods for Built-In Classes13-4. Providing Constructors for Your Classes13-5. Marking Slots As “Private”13-6. Changing the Argument Precedence Order13-7. Automatically Initializing Slots on First Usage13-8. Changing and Redefining Classes on the FlyObjects Changing Their ClassRedefining Classes13-9. Making Your Objects Externalizable13-10. Using and Defining Non-Standard Method CombinationsRolling Your OwnArbitrarily Complex Method Combinations13-11. Extending and Modifying CLOSWhat the example does
14. I/O: Streams and Files
14-1. Redirecting StreamsOther Ways to Do ItSynonym Streams14-2. Flushing an Output Stream14-3. Determining the Size of a File14-4. Reading a Whole File at OnceAlternatives14-5. Sending Data to Two Streams in ParallelSynonym Streams14-6. Sending Data to “ /dev/null ”14-7. Pretending a String Is a StreamMore Details14-8. Concatenating Streams14-9. Processing Text Files Line by LineWhat Happens at the End of a Line?What Happens at the End of the File?14-10. Working with Binary DataReading or Writing Several Bytes at OnceYou Might Get Bigger Chunks Than You Asked For14-11. Reading “Foreign” Binary DataFloating-Point Values14-12. Using Random Access I/ODifferent Characters May Have Different Lengths14-13. Serializing Lisp ObjectsShared StructureIs It Readable?Can This Be Done Faster, Please?What About JSON or Other Formats?14-14. Customizing Stream Behavior
15. Pathnames, Files, Directories
15-1. Getting and Setting the Current DirectoryShortcuts and Deviations15-2. Testing Whether a File ExistsWhat About Directories?15-3. Creating a DirectoryImplementation-Specific AlternativesWhat Might Go Wrong15-4. Finding Files Matching a Pattern15-5. Splitting a Filename into its Component Parts15-6. Renaming a FileImplementation-Specific AlternativesDon’t Expect “Move” Behavior!15-7. Deleting a FileWhat Does “Success” Mean Anyway?15-8. Deleting a Directory15-9. Copying a File15-10. Processing the Contents of a Directory RecursivelyThe CL-FAD Library15-11. Getting the Pathname a Stream Is AssociatedWith15-12. Dealing with Symbolic LinksWhat If I Want the Symlinks?15-13. Navigating a Directory Tree15-14. Figuring Out (Source) File Locations Programmatically15-15. Understanding Logical PathnamesWhat Exactly Are Logical Pathnames?So, Maybe Logical Pathnames Aren’t Totally Useless.
16. Developing and Debugging
16-1. Embracing Lisp’s Image-Based Development StyleThe Role of the Source Code16-2. Deciding Which IDE to UseA Brief History of Emacs (As Seen from Lisp)Alternatives (?)16-3. Debugging with the DebuggerEntering the Debugger IntentionallyWithout SLIMELogging Backtraces16-4. Tracing FunctionsGraphical Tracing16-5. Stepping Through Your Code16-6. Acquiring Information About Functions, Macros, and VariablesAccessing the HyperSpecCross-Reference Information16-7. Inspecting and Modifying (Compound) ObjectsThe SLIME Inspector16-8. Browsing Your Lisp ImageAlternatives16-9. “Undoing” Definitions16-10. Distinguishing Your IDE’s Streams16-11. Utilizing the REPL’s MemoryIDE History Features16-12. Recording Your Work
17. Optimization
17-1. Understanding the Importance of the Right Algorithms17-2. Deciding If and Where to OptimizeInstrumentationStatistical ProfilingSome Things Cannot Be ProfiledWhere to Go From HereA Warning About Empirical DataWhat Does TIME Do?CPUs Can Deceive You17-3. Asking the Compiler to OptimizeImplementation-Defined Optimize QualitiesCan I Have This Global, Please?Compilers Aren’tWizards17-4. Obtaining Optimization Hints from the Compiler17-5. Helping the Compiler by Providing Type InformationGeneric OperationsBoxingHow to Declare TypesThe Scope of Type DeclarationsDeclaring the Return Type of FormsType InferencePitfalls17-6. Reducing “Consing”“Consing” and the HeapReusing Data StructuresDestructive Functions“Hidden” Consing“Tuning” the Garbage Collector17-7. Using the Stack Instead of the HeapMultiple Values17-8. Optimizing Recursive Functions17-9. Helping the Compiler with Alternative Implementation Strategies .17-10. Avoiding Repeated Computations17-11. Avoiding Function CallsAlternatives That Aren’t Really AlternativesThe NOTINLINE Declaration and Compiler Macros17-12. Utilizing the Disassembler17-13. Switching to Machine CodeInline Assembly Code17-14. Optimizing Array Access17-15. Comparing Different Implementations
18. Libraries
18-1. Organizing Your CodeComponentsDependenciesHow Does ASDF Find System Definitions?Additional InformationWhat About the Names?Advanced Usage of ASDF18-2. Employing Open Source LibrariesInstalling QUICKLISPUsing QUICKLISP for Your Own Code18-3. Creating a Project’s Skeleton Automatically18-4. Avoiding Wheel-Reinvention18-5. Using Libraries to Write Portable Code18-6. Utilizing Regular ExpressionsRegex SyntaxScannersConvenience FeaturesModifying and Dissecting StringsMore Information18-7. Obtaining Data via HTTPParsing HTML18-8. Creating DynamicWeb Sites with LispGenerating HTMLWeb Frameworks
19. Interfacing with Other Languages
19-1. Calling C Functions from LispHow the FFI Finds and Loads Shared LibrariesHow the FFI Calls C FunctionsHow the FFI Converts Between C and Lisp TypesThe “ stdcall Problem”19-2. Working with C PointersTyped Pointers19-3. Accessing and Generating C ArraysGiving C Access to Lisp Arrays19-4. Handling C Structs and UnionsPassing Structs by Value19-5. Converting Between Lisp and C Strings19-6. Calling Lisp Functions from C19-7. Generating FFI Code Automatically19-8. Embedding C in COMMON LISP19-9. Calling C++ from LispAutomating the ProcessECL and C LASP19-10. Using JAVA from LispAlternatives19-11. Reading andWriting JSON19-12. Reading andWriting XML19-13. Using PROLOG from COMMON LISP
20. Graphical User Interfaces
20-1. Using aWeb Browser as the GUI for Your Lisp ProgramWhat the Example Does20-2. Building Applications with the “ Lisp Toolkit ”What the Example Does20-3. Creating COMMON LISP GUIs Through JAVAWhat the Example DoesA Better Example20-4. Using CAPI to Build Graphical User InterfacesWhat the Example Does20-5. Using Lisp on Mobile DevicesAlternatives
21. Persistence
21-1. Serializing Your Data21-2. Accessing Relational Databases21-3. Keeping Your Database in RAM21-4. Using a Lisp Object Database
22. TheWorld Outside
22-1. Accessing Environment VariablesThe Windows Registry and Application-Specific Settings22-2. Accessing the Command-Line Arguments22-3. Querying Your Lisp for Information About Its Environment22-4. Delivering Stand-Alone ExecutablesDelivering Programs with the Commercial Lisps22-5. Customizing Your LispSaving an Image22-6. Running External Programs22-7. Embedding LispCreating Shared Libraries with LISP WORKSEmbedding ABCL in a JAVA Program22-8. Measuring Time22-9. Working with Dates and TimesThe LOCAL - TIME Library22-10. Working with the Garbage CollectorFinalizers
Index

Content preview from Common Lisp Recipes: A Problem-Solution Approach

Table of Contents

About the Author

About the Technical Reviewer

Preface

Who This Book Is For

Who This Book Is (Probably) Not For

How to Read This Book

What’s In and What Not

Typographical Conventions

Acknowledgements

1. Symbols and Packages

1-1. Understanding the Role of Packages and the Symbol Nomenclature

1-2. Making Unique Symbols

1-3. Making Symbols Inaccessible

How Can We Fix This?

1-4. Avoiding Name Conflicts

When Name Conflicts Do Not Occur

1-5. Using Symbols As Stand-Ins for Arbitrary Forms

1-6. Searching for Symbols by Name

1-7. Iterating Through All Symbols of a Package

What To Do If You Don’t Like LOOP

1-8. Understanding COMMON LISP ’s Case (In)Sensitivity

Style Hint: Don’t Use ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Interpreting LISP: Programming and Data Structures, Second Edition

Publisher Resources

ISBN: 9781484211762Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Common Lisp Recipes: A Problem-Solution Approach

by Edmund Weitz

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.