Return to home page
Searching: Muskingum library catalog
  Previous Record Previous Item Next Item Next Record
  Reviews, Summaries, etc...
EBOOK
Author Weitz, E. (Edmund), 1965-
Title Common LISP recipes : a problem-solution approach / Edmund Weitz.
Imprint [Berkeley, California] : Apress, 2016.
New York, NY : Distributed to the Book trade worldwide by Springer
2016

LOCATION CALL # STATUS MESSAGE
 OHIOLINK SPRINGER EBOOKS    ONLINE  
View online
Series The expert's voice in LISP
Expert's voice in LISP.
Subject LISP (Computer program language)
Add Title Common List processing computer language recipes
LOCATION CALL # STATUS MESSAGE
 OHIOLINK SPRINGER EBOOKS    ONLINE  
View online
Series The expert's voice in LISP
Expert's voice in LISP.
Subject LISP (Computer program language)
Add Title Common List processing computer language recipes
Description 1 online resource (xxvii, 744 pages) : illustrations.
Summary Find solutions to problems and answers to questions you are likely to encounter when writing real-world applications in Common Lisp. 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. Written by an author who has used Common Lisp in many successful commercial projects over more than a decade, Common Lisp Recipes 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.
Bibliography Note Includes bibliographical references and index.
Contents Machine generated contents note: 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 CamelCase! -- 1-9. Using Symbols As String Substitutes -- So, What Should You Use? -- 1-10. "Overloading" of Standard Common Lisp Operators -- 2. Conses, Lists, and Trees -- 2-1. Understanding Conses -- List Access -- Testing Whether Something Is a Cons or a List -- 2-2. Creating Lists -- Converting Vectors to Lists -- 2-3. Transposing a Matrix -- 2-4. Using List Interpolation -- 2-5. Adding Objects to the End of a List -- Tail Wagging the List -- 2-6. "Splicing" into a List -- 2-7. Detecting Shared Structure in Lists -- Isolating the Non-Shared Part -- 2-8. Working with Trees -- More Complicated Trees -- Common Lisp's Standard Tree Functions -- 2-9. Working with Stacks -- 2-10. Implementing a Queue -- 2-11. Destructuring and Pattern Matching -- 3. Strings and Characters -- 3-1. Getting the ASCII Code of a Character -- Other Way Around -- Limit -- 3-2. Naming Characters -- 3-3. Using Different Character Encodings -- 3-4. Comparing Strings or Characters -- Internationalization -- 3-5. Escaping Characters in String Literals and Variable Interpolation -- Is It Still a Literal? -- 3-6. Controlling Case -- What About Unicode? -- 3-7. Accessing or Modifying a Substring -- 3-8. Finding a Character or a Substring Within a String -- 3-9. Trimming Strings -- 3-10. Processing a String One Character at a Time -- 3-11. Joining Strings -- 3-12. Reading CSV Data -- 4. Numbers and Math -- 4-1. Using Arbitrarily Large Integers -- 4-2. Understanding Fixnums -- 4-3. Performing Modular Arithmetic -- Efficiency Considerations -- 4-4. Switching Bases -- 4-5. Performing Exact Arithmetic with Rational Numbers -- Various Ways of Converting Numbers to Integers -- How Not to Use FLOOR and Friends -- Converting Floating-Point Numbers to Rationals and Vice Versa -- Mixing Rationals and Floats -- 4-6. Controlling the Default Float Format -- 4-7. Employing Arbitrary Precision Floats -- 4-8. Working with Complex Numbers -- 4-9. Parsing Numbers -- 4-10. Testing Whether Two Numbers Are Equal -- Don't Ever Use EQ with Numbers! -- 4-11. Computing Angles Correctly -- 4-12. Calculating Exact Square Roots -- 5. Arrays and Vectors -- 5-1. Working with Multiple Dimensions -- 5-2. Understanding Vectors and Simple Arrays -- 5-3. Obtaining the Size of an Array -- 5-4. Providing Initial Contents -- Warning About Identical Objects -- 5-5. Treating Arrays As Vectors -- 5-6. Making the Length of Vectors Flexible -- 5-7. Adjusting Arrays -- 5-8. Using an Array As a "Window" into Another Array -- 5-9. Restricting the Element Type of an Array -- Upgrading Element Types -- 5-10. Copying an Array -- Warning About Object Identity -- 6. Hash Tables, Maps, and Sets -- 6-1. Understanding the Basics of Hash Tables -- Why Does GETHASH Return Two Values? -- How Many Entries Does the Hash Table Have? -- 6-2. Providing Default Values For Hash Table Lookups -- 6-3. Removing Hash Table Entries -- 6-4. Iterating Through a Hash Table -- Don'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 Own -- What Is SXHASH For? -- 6-6. Controlling Hash Table Growth -- 6-7. Getting Rid of Hash Table Entries Automatically -- 6-8. Representing Maps As Association Lists -- Combining Lookup and Manipulation -- Why Would Anybody Prefer Alists over Hash Tables? -- 6-9. Representing Maps As Property Lists -- When to Prefer Plists over Alists -- Plist of a Symbol -- 6-10. Working with Sets -- Representing Sets As Hash Tables -- Representing Sets As Bit Patterns -- 7. Sequences and Iteration -- 7-1. Filtering a Sequence -- 7-2. Searching a Sequence -- 7-3. Sorting and Merging Sequences -- 7-4. Mixing Different Sequence Types -- 7-5. Re-Using a Part of a Sequence -- 7-6. Repeating Some Values Cyclically -- Alternatives -- 7-7. Counting Down -- 7-8. Iterating over "Chunks" of a List -- 7-9. Closing over Iteration Variables -- 7-10. "Extending" Short Sequences in Iterations -- 7-11. Breaking out of LOOP -- 7-12. Making Sense of the MAP ...
Zoo -- Sequence Variants -- 7-13. Defining Your Own Sequence Types -- 7-14. Iterating with Iterate -- 7-15. Iterating with Series -- What the Example Does -- 8. Lisp Reader -- 8-1. Employing the Lisp Reader for Your Own Code -- Why READ Is Potentially Dangerous -- What READ Doesn't Do -- Optional Arguments to READ -- Go Wild! -- 8-2. Troubleshooting Literal Object Notation -- This Also Applies to Strings! -- 8-3. Evaluating Forms at Read Time -- What to Look Out For -- Alternatives -- 8-4. Embedding Literal Arrays into Your Code -- Usual Warning -- 8-5. Understanding the Different Ways to Refer to a Function -- 8-6. Repeating Something You Already Typed -- They Don't Only Look Identical, They Are Identical! -- 8-7. Safely Experimenting with Read tables -- Temporarily Switching to Standard IO Syntax -- 8-8. Changing the Syntax Type of a Character -- Six Syntax Types -- How to Actually Change the Syntax Type -- Some Things Never Change -- 8-9. Creating Your Own Reader Macros -- What Reader Macro Functions Do -- 8-10. Working with Dispatching Macro Characters -- 8-11. Preserving Whitespace -- 9. Printing -- 9-1. Using the Printing Primitives -- Printing Objects So That They Can Be Read Back in Again -- Shortcuts -- 9-2. Printing to and into Strings -- 9-3. Printing NIL As a List -- 9-4. Extending FORMAT Control Strings Over More Than One Line -- 9-5. Using Functions As FORMAT Controls -- 9-6. Creating Your Own FORMAT Directives -- 9-7. Recursive Processing of FORMAT Controls -- 9-8. Controlling How Your Own Objects Are Printed -- 9-9. Controlling the Pretty Printer -- 9-10. Printing Long Lists -- 9-11. Pretty-Printing Compound Objects -- Using the Pretty Printer from FORMAT -- 9-12. Modifying the Pretty Printer -- 10. Evaluation, Compilation, Control Flow -- 10-1. Comparing Arbitrary Lisp Objects -- Comparing State -- Constants -- 10-2. Using Constant Variables as Keys in CASE Macros -- 10-3. Using Arbitrary Variable Names for Keyword Parameters -- Keyword Names Don't Have to Be Keywords -- Keyword Dames Don't Have to Be Constant -- 10-4. Creating "Static Local Variables," Like in C -- 10-5. "Preponing" the Computation of Values -- 10-6. Modifying the Behavior of Functions You Don't Have the Source Of -- 10-7. Swapping the Values of Variables (or Places) -- 10-8. Creating Your Own Update Forms for "Places" -- Using DEFSETF -- Using DEFINE -- SETF -- EXPANDER -- So, Which One Do I Use? -- Using DEFINE -- MODIFY -- MACRO -- Multiple-Valued Places -- 10-9. Working with Environments -- 10-10. Commenting Out Parts of Your Code -- Some Notes About; and #I -- How;, #I, and Others Are Implemented -- 11. Concurrency -- 11-1. Managing Lisp Processes -- Escape Hatches -- Threads Are Expensive -- 11-2. Accessing Shared Resources Concurrently -- Locks -- Atomic Operations -- More Problems -- 11-3. Using Special Variables in Concurrent Programs -- Per-Thread Initial Bindings -- Variables That Are Always Global -- 11-4. Communicating with Other Threads -- Alternatives -- 11-5. Parallelizing Algorithms Without Threads and Locks -- What the Example Does -- Fine-Tuning -- Ptrees -- Alternatives -- 11-6. Determining the Number of Cores -- 12. Error Handling and Avoidance -- 12-1. Checking Types at Run Time -- Alternatives -- 12-2. Adding Assertions to Your Code -- Disabling Assertions in "Production Code" -- 12-3. Defining Your Own Conditions -- How Conditions Are Printed -- 12-4. Signaling a Condition -- Condition Designators -- 12-5. Handling Conditions -- Ignoring Errors -- 12-6. Providing and Using Restarts -- Visible Restarts -- Predefined Restarts -- 12-7. Getting Rid of Warning Messages -- 12-8. Protecting Code from Non-Local Exits -- "WITH -- " Macros -- 13. Objects, Classes, Types -- 13-1. Defining Types -- Compound Type Specifiers -- Derived Types -- 13-2. Using Classes As Types -- 13-3. Writing Methods for Built-In Classes -- 13-4. Providing Constructors for Your Classes -- 13-5. Marking Slots As "Private" -- 13-6. Changing the Argument Precedence Order -- 13-7. Automatically Initializing Slots on First Usage -- 13-8. Changing and Redefining Classes on the Fly -- Objects Changing Their Class -- Redefining Classes -- 13-9. Making Your Objects Externalizable -- 13-10. Using and Defining Non-Standard Method Combinations -- Rolling Your Own -- Arbitrarily Complex Method Combinations -- 13-11. Extending and Modifying CLOS -- What the example does -- 14. I/O: Streams and Files -- 14-1. Redirecting Streams -- Other Ways to Do It -- Synonym Streams -- 14-2. Flushing an Output Stream -- 14-3. Determining the Size of a File -- 14-4. Reading a Whole File at Once -- Alternatives -- 14-5. Sending Data to Two Streams in Parallel -- Synonym Streams -- 14-6. Sending Data to "/dev/null"
Note continued: 14-7. Pretending a String Is a Stream -- More Details -- 14-8. Concatenating Streams -- 14-9. Processing Text Files Line by Line -- What Happens at the End of a Line? -- What Happens at the End of the File? -- 14-10. Working with Binary Data -- Reading or Writing Several Bytes at Once -- You Might Get Bigger Chunks Than You Asked For -- 14-11. Reading "Foreign" Binary Data -- Floating-Point Values -- 14-12. Using Random Access I/O -- Different Characters May Have Different Lengths -- 14-13. Serializing Lisp Objects -- Shared Structure -- Is 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 Directory -- Shortcuts and Deviations -- 15-2. Testing Whether a File Exists -- What About Directories? -- 15-3. Creating a Directory -- Implementation-Specific Alternatives -- What Might Go Wrong -- 15-4. Finding Files Matching a Pattern -- 15-5. Splitting a Filename into its Component Parts -- 15-6. Renaming a File -- Implementation-Specific Alternatives -- Don't Expect "Move" Behavior! -- 15-7. Deleting a File -- What Does "Success" Mean Anyway? -- 15-8. Deleting a Directory -- 15-9. Copying a File -- 15-10. Processing the Contents of a Directory Recursively -- CL-FAD Library -- 15-11. Getting the Pathname a Stream Is Associated With -- 15-12. Dealing with Symbolic Links -- What If I Want the Symlinks? -- 15-13. Navigating a Directory Tree -- 15-14. Figuring Out (Source) File Locations Programmatically -- 15-15. Understanding Logical Pathnames -- What Exactly Are Logical Pathnames? -- So, Maybe Logical Pathnames Aren't Totally Useless -- 16. Developing and Debugging -- 16-1. Embracing Lisp's Image-Based Development Style -- Role of the Source Code -- 16-2. Deciding Which IDE to Use -- Brief History of Emacs (As Seen from Lisp) -- Alternatives (?) -- 16-3. Debugging with the Debugger -- Entering the Debugger Intentionally -- Without SLIME -- Logging Backtraces -- 16-4. Tracing Functions -- Graphical Tracing -- 16-5. Stepping Through Your Code -- 16-6. Acquiring Information About Functions, Macros, and Variables -- Accessing the HyperSpec -- Cross-Reference Information -- 16-7. Inspecting and Modifying (Compound) Objects -- SLIME Inspector -- 16-8. Browsing Your Lisp Image -- Alternatives -- 16-9. "Undoing" Definitions -- 16-10. Distinguishing Your IDE's Streams -- 16-11. Utilizing the REPL's Memory -- IDE History Features -- 16-12. Recording Your Work -- 17. Optimization -- 17-1. Understanding the Importance of the Right Algorithms -- 17-2. Deciding If and Where to Optimize -- Instrumentation -- Statistical Profiling -- Some Things Cannot Be Profiled -- Where to Go From Here -- Warning About Empirical Data -- What Does TIME Do? -- CPUs Can Deceive You -- 17-3. Asking the Compiler to Optimize -- Implementation-Defined Optimize Qualities -- Can I Have This Global, Please? -- Compilers Aren't Wizards -- 17-4. Obtaining Optimization Hints from the Compiler -- 17-5. Helping the Compiler by Providing Type Information -- Generic Operations -- Boxing -- How to Declare Types -- Scope of Type Declarations -- Declaring the Return Type of Forms -- Type Inference -- Pitfalls -- 17-6. Reducing "Consing" -- "Consing" and the Heap -- Reusing Data Structures -- Destructive Functions -- "Hidden" Consing -- "Tuning" the Garbage Collector -- 17-7. Using the Stack Instead of the Heap -- Multiple Values -- 17-8. Optimizing Recursive Functions -- 17-9. Helping the Compiler with Alternative Implementation Strategies -- 17-10. Avoiding Repeated Computations -- 17-11. Avoiding Function Calls -- Alternatives That Aren't Really Alternatives -- Notinline Declaration and Compiler Macros -- 17-12. Utilizing the Disassembler -- 17-13. Switching to Machine Code -- Inline Assembly Code -- 17-14. Optimizing Array Access -- 17-15. Comparing Different Implementations -- 18. Libraries -- 18-1. Organizing Your Code -- Components -- Dependencies -- How Does ASDF Find System Definitions? -- Additional Information -- What About the Names? -- Advanced Usage of ASDF -- 18-2. Employing Open Source Libraries -- Installing Quicklisp -- Using Quicklisp for Your Own Code -- 18-3. Creating a Project's Skeleton Automatically -- 18-4. Avoiding Wheel-Reinvention -- 18-5. Using Libraries to Write Portable Code -- 18-6. Utilizing Regular Expressions -- Regex Syntax -- Scanners -- Convenience Features -- Modifying and Dissecting Strings -- More Information -- 18-7. Obtaining Data via HTTP -- Parsing HTML -- 18-8. Creating Dynamic Web Sites with Lisp -- Generating HTML -- Web Frameworks -- 19. Interfacing with Other Languages -- 19-1. Calling C Functions from Lisp -- How the FFI Finds and Loads Shared Libraries -- How the FFI Calls C Functions -- How the FFI Converts Between C and Lisp Types -- "stdcall Problem" -- 19-2. Working with C Pointers -- Typed Pointers -- 19-3. Accessing and Generating C Arrays -- Giving C Access to Lisp Arrays -- 19-4. Handling C Structs and Unions -- Passing Structs by Value -- 19-5. Converting Between Lisp and C Strings -- 19-6. Calling Lisp Functions from C -- 19-7. Generating FFI Code Automatically -- 19-8. Embedding C in Common Lisp -- 19-9. Calling C++ from Lisp -- Automating the Process -- ECL and Clasp -- 19-10. Using Java from Lisp -- Alternatives -- 19-11. Reading and Writing JSON -- 19-12. Reading and Writing XML -- 19-13. Using Prolog from Common Lisp -- 20. Graphical User Interfaces -- 20-1. Using a Web Browser as the GUI for Your Lisp Program -- What the Example Does -- 20-2. Building Applications with the "Lisp Toolkit" -- What the Example Does -- 20-3. Creating Common Lisp GUIs Through Java -- What the Example Does -- Better Example -- 20-4. Using CAPI to Build Graphical User Interfaces -- What the Example Does -- 20-5. Using Lisp on Mobile Devices -- Alternatives -- 21. Persistence -- 21-1. Serializing Your Data -- 21-2. Accessing Relational Databases -- 21-3. Keeping Your Database in RAM -- 21-4. Using a Lisp Object Database -- 22. World Outside -- 22-1. Accessing Environment Variables -- Windows Registry and Application-Specific Settings -- 22-2. Accessing the Command-Line Arguments -- 22-3. Querying Your Lisp for Information About Its Environment -- 22-4. Delivering Stand-Alone Executables -- Delivering Programs with the Commercial Lisps -- 22-5. Customizing Your Lisp -- Saving an Image -- 22-6. Running External Programs -- 22-7. Embedding Lisp -- Creating Shared Libraries with LispWorks -- Embedding ABCL in a JAVA Program -- 22-8. Measuring Time -- 22-9. Working with Dates and Times -- Local-Time Library -- 22-10. Working with the Garbage Collector -- Finalizers.
Note Online resource; title from PDF title page (SpringerLink, viewed January 8, 2016).
ISBN 9781484211762 (electronic bk.)
1484211766 (electronic bk.)
9781484211779
1484211774
ISBN/ISSN 10.1007/978-1-4842-1176-2
OCLC # 934096903
Additional Format Print version: Weitz, E. (Edmund), 1965- Common LISP recipes. 1484211774 9781484211779 (OCoLC)920847127