[Haskell-cafe] Designing a DSL?

S. Doaitse Swierstra doaitse at swierstra.net
Mon Oct 5 10:06:35 EDT 2009

On 2 okt 2009, at 20:37, Jake McArthur wrote:

> Günther Schmidt wrote:
>> And that I find to be the really tricky part, how do I *design* a  
>> DSL?

I once wrote a tutorial on this subject in which I explain that  
designing a DSL is not so much different from an ordinary programming  
language; the only difference is that you do not have to think about  
type systems and abstraction mechanisms. The tutorial can be found in:

	Author = {Swierstra, S. Doaitse and Azero~Alcocer, Pablo R. and  
Saraiva, Jo{\~a}o A.},
	Booktitle = {Advanced Functional Programming, Third International  
School, AFP'98},
	Date-Added = {2008-07-15 17:22:15 +0200},
	Date-Modified = {2009-01-16 17:35:05 +0100},
	Editor = {Swierstra, S. D. and Henriques, Pedro and Oliveira, Jos 
	Pages = {150-206},
	Publisher = {Springer-Verlag},
	Series = {LNCS},
	Title = {Designing and Implementing Combinator Languages},
	Volume = {1608},
	Year = {1999}}

It basically describes the origins of the Utrecht Attribute Grammar  
System, uuagc, available from hackage; the basic message is that when  
you implement a language you use compiler construction tools! An  
example of this can be found in a paper Olaf Chitil and I recently  
published in the JFP:

	Date-Added = {2009-02-13 10:17:23 +0100},
	Date-Modified = {2009-02-13 10:17:23 +0100},
	Doi = {10.1017/S0956796808006990},
	Eprint = {http://journals.cambridge.org/article_S0956796808006990},
	Journal = {Journal of Functional Programming},
	Number = {01},
	Pages = {1-16},
	Title = {Linear, bounded, functional pretty-printing},
	Url = {http://journals.cambridge.org/action/displayAbstract?fromPage=online&aid=2837460&fulltextType=RC&fileId=S0956796808006990 
	Volume = {19},
	Year = {2009},
	Abstract = { ABSTRACT We present two implementations of Oppen's  
pretty-printing algorithm in Haskell that meet the efficiency of  
Oppen's imperative solution but have a simpler and a clear structure.  
We start with an implementation that uses lazy evaluation to simulate  
two co-operating processes. Then we present an implementation that  
uses higher-order functions for delimited continuations to simulate co- 
routines with explicit scheduling. },
	Bdsk-Url-1 = {http://journals.cambridge.org/action/displayAbstract?fromPage=online&aid=2837460&fulltextType=RC&fileId=S0956796808006990 
	Bdsk-Url-2 = {http://dx.doi.org/10.1017/S0956796808006990}}

This paper describes two implementation of a functional pretty  
printing, finally solving the problem how to do so with limited alook- 
ahead, as in Oppen's orginal paper. One of the solutions was created  
using an attribute grammar way of thinking and the attribute grammar  
can be found at the end of the technical report, and I hope that this  
example convinces you of the elegance of this approach:

	Author = {Swierstra, S.D.},
	Date-Added = {2009-01-04 17:21:54 +0100},
	Date-Modified = {2009-01-04 17:21:54 +0100},
	Institution = {Inst. of Information and Comp. Science, Utrecht Univ.},
	Note = {submitted for publication},
	Number = {UU-CS-2004-025a},
	Pubcat = {techreport},
	Title = {Linear, Online, Functional Pretty printing (extended and  
corrected version)},
	Urlpdf = {{http://archive.cs.uu.nl/pub/RUU/CS/techreps/CS-2004/2004-025a.pdf 
	Year = 2004}

In a more abstract setting your question is also "How do I design a  
library", "How do I design a consistent theory", and "How do I model  
something". These questions are harder to answer ;-}

  Doaitse Swierstra

More information about the Haskell-Cafe mailing list