Not sure if I'd call it a "pearl", but here's one data point. Hell, I'm not even sure if this counts as a DSL or not, most of what I know of DSLs comes from blog posts and ruby fanatics.
I had a legacy electronic voting system (IIS/VBscript/SQL Server) and wrote some lisp to configure elections. The lisp code output the T-SQL needed to configure the election, and then the VBScript was driven from that data.
Here's an abbreviated example:
(with-election ("3/29/2011 8:00PM" "3/31/2011 7:00PM" "Law") (with-position ("President" :types '("Law Undergrad")) (make-candidates "name 1" "name 2" "name 3")) (make-referendum "Amendment 1" "<strong>Thing To Change</strong> <p>HTML body for the voting UI</p>"))
The :types indicated who was eligible to vote for the position, and there were some other options to those macros. The with-* forms are macros to setup the context, and the make-* functions generate the appropriate SQL strings and write them to a stream (usually a file).
The macros in the sample do a few things:
1. with-election: sets a dynamic variable in lisp for the stream all the SQL strings are written to in make-* functions, allowed easy testing of make-* functions via the REPL 2. with-position: sets a variable in the T-SQL script used by INSERT statements produced by make-candidates. This actually macroexpands to imperative code: (progn (make-position ...) (make-candidates ...)). The macro usage is mostly to get indentation and visually group the relationships
So, not sure if I'd call this a pearl and it's arguably a DSL, but it's sure a lot easier for me to use than direct T-SQL or the ridiculous VBScript web interface.
Other things I've used that might fall into the DSL category:
* cl-who http://weitz.de/cl-who/ * cl-interpol http://weitz.de/cl-interpol/ * clsql's SQL-READER syntax (http://clsql.b9.com/manual/ref-syntax.html)
HTH,
Ryan Davis Acceleration.net Director of Programming Services 2831 NW 41st street, suite B Gainesville, FL 32606
Office: 352-335-6500 x 124 Fax: 352-335-6506
On 7/20/2011 9:32 AM, Didier Verna wrote:
Dear friends,
I'm starting to write a chapter for an upcoming book on domain specific languages. The chapter is called (tentatively):
Extensible languages -- blurring the distinction between DSLs and GPLs
GPL meaning General Purpose Language in this context ;-)
My intention is to demonstrate how the task of implementing a DSL is made easier when it boils down to an extension or subset of your original GPL (hence reusing its infrastructure), instead of being a totally different language, only written on top of the other.
Obviously, I'm going to illustrate this with Common Lisp, and I intend to speak of dynamicity (not only dynamic typing, but in general all things that can be deferred to the run-time), introspection, intersession, structural or procedural reflexivity, meta-object protocols (not sure about this one), macro systems and JIT-compilation. Also, more specifically to Lisp, reader macros (compiler macros maybe?), the condition system (and its ability to *not* unwind) and restarts.
Right now, I would like to know if any of you have DSL "pearls", nice examples of DSLs that you have written in Lisp by using some of its features in a clever or elegant way. I would also gladly accept any point of view or comment on what's important to mention, in terms of design principle or anything else, things that I may have missed in the list above.
Thank you very much in advance!