- 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
Because Lisp has such a simple syntax (everything is delimited with parentheses), it is easy to use it to build your own custom programming language, designed for a specific domain. Such domain-specific languages (DSLs) tend to make heavy use of the Lisp macro system. They represent an extreme form of macro programming, transforming Lisp into a completely new programming language.
This is an example of code that uses a DSL to build an HTML page. In this case, the page displays “Hello World” in a browser, with the second word rendered in bold. The html and body commands (macros created for the HTML library in Chapter 16) generate opening and closing tags that will contain the body of the page 
. Then it calls the regular Lisp function princ to generate the text. The second word is wrapped in another custom DSL command, bold 
, which generates opening and closing bold tags around the specified text.
Since DSLs are programming languages you create all by yourself, you can definitely shoot yourself in the foot if you aren’t careful. It’s easy to create code in a language that is impossible for others (and perhaps even you) to understand.
Chapter 17 discusses DSLs, including the DSL that allows you to write HTML directly inside your Lisp code, as shown in this example.
-
No Comment