- Land of Lisp
- Acknowledgments
- Introduction
- I. Lisp is Power
- 1. Getting Started with Lisp
- 2. Creating Your First Lisp Program
- 3. Exploring the Syntax of Lisp Code
- II. Lisp is Symmetry
- 4. Making Decisions with Conditions
- 5. Building a Text Game Engine
- 6. Interacting with the World: Reading and Printing in Lisp
- 6.5. lambda: A Function So Important It Deserves Its Own Chapter
- 7. Going Beyond Basic Lists
- 8. This Ain't Your Daddy's Wumpus
- 9. Advanced Datatypes and Generic Programming
- III. Lisp is Hacking
- 10. Looping with the loop Command
- 11. Printing Text with the format Function
- Anatomy of the format Function
- Control Sequences for Printing Lisp Values
- Control Sequences for Formatting Numbers
- Printing Multiple Lines of Output
- Justifying Output
- Iterating Through Lists Using Control Sequences
- A Crazy Formatting Trick for Creating Pretty Tables of Data
- Attack of the Robots!
- What You've Learned
- 12. Working with Streams
- 13. Let's Create a Web Server!
- 13.5. Functional Programming Is Beautiful
- IV. Lisp is Science
- 14. Ramping Lisp Up a Notch with Functional Programming
- 15. Dice of Doom, a Game Written in the Functional Style
- The Rules of Dice of Doom
- A Sample Game of Dice of Doom
- Implementing Dice of Doom, Version 1
- Defining Some Global Variables
- Representing the Game Board
- Decoupling Dice of Doom's Rules from the Rest of the Game
- Generating a Game Tree
- Calculating Passing Moves
- Calculating Attacking Moves
- Finding the Neighbors
- Attacking
- Reinforcements
- Trying Out Our New game-tree Function
- Playing Dice of Doom Against Another Human
- Creating an Intelligent Computer Opponent
- Making Dice of Doom Faster
- What You've Learned
- 16. The Magic of Lisp Macros
- 17. Domain-Specific Languages
- 18. Lazy Programming
- 19. Creating a Graphical, Web-Based Version of Dice of Doom
- 20. Making Dice of Doom More Fun
- A. Epilogue
- Index
- About the Author
- Updates
One of the best reasons for using macros is to perform domain-specific language (DSL) programming. DSL programming is an advanced macro programming technique that allows us to solve difficult programming problems by drastically changing the structure and appearance of Lisp code to optimize it for a specialized purpose. Although macros are not strictly necessary for doing DSL programming, by writing a set of macros, you can easily create a DSL in Lisp.
According to the 2000 US Census, the average family in the United States had 1.86 children. Since no individual family has exactly 1.86 children, it is obvious that no particular family is truly perfectly average. In the same way, there is no such thing as an average computer program. Every program is designed to solve a specific problem, and every area of human inquiry, or domain, has its own idiosyncratic requirements that influence programs that solve problems in the given area. With DSLs, we enhance the core of our programming language to take these domain-specific requirements into account, potentially making our resulting code easier to write and understand.
Let’s take a look at some specific domains and create some DSLs that let us easily work within these domains using Lisp. In this chapter, we’ll create two different DSLs. First, we’ll create a DSL for writing scalable vector graphics (SVG) files. Then we’ll write a DSL for creating commands in a text adventure—we’re finally going to upgrade our Wizard’s Adventure Game from Chapter 5 and Chapter 6 to make it fully playable!
-
No Comment