Hello! In my master's thesis I am dealing with a complicated case of pretty printing / unparsing. There are side effects, context dependency, unparsing to two different languages (two SQL dialects). To manage this complexity, I use a couple of ,,design patterns''. One of them is about giving a monadic interface to pretty printing library, to allow mixing it easily with various effects (IO, Reader, Cont). After some fiddling with a hand written pretty-printing monad, I realized that I can just use a Writer monad. HughesPJ.Doc can be trivially made an instance of Monoid - AFAIK all the needed laws hold. The only problem is to decide which one of document composition operators should be used as mappend. In my case I want <+> by default, but I arranged things so that I can have several different versions of Doc (newtyped). As I needed many other pretty-printing combinators beside <+>/mappend, I created a library of monadic pretty-printing combinators for separating (eg. with commas), vertical composition, nesting, putting in parentheses, <> composition, etc. In some cases it was necessary to use MonadWriter's "censor" method, but nothing more. I think it is quite elegant. The code written using this technique is also quite clear. Perhaps it would be worse, if it wasn't possible to choose a composition operator for Monoid doing the proper thing in 90% of cases. Below is a fragment of code that handles expression unparsing. unparse (Expr_BinaryOp op e1 e2) = parens $ do unparse e1 unparse op unparse e2 unparse (Expr_UnaryOp UnaryOp_Not (Expr_IsNull e)) = parens $ do unparse e kw IS kw NOT kw NULL unparse (Expr_UnaryOp op e) = parens $ do unparse op unparse e unparse (Expr_Constant cons) = do unparse cons unparse (Expr_In e inSpec) = parens $ do unparse e kw IN oneline (unparse inSpec) unparse (Expr_Between e1 e2 e3) = parens $ do unparse e1 kw BETWEEN unparse e2 kw AND unparse e3 unparse (Expr_Cast e datatype) = do kw CAST `catThen` parens (do unparse e kw AS unparse datatype) unparse (Expr_IsNull e) = parens $ do unparse e kw IS kw NULL ... As you can see, sometimes there is a need to use a different composition operator (catThen). I think that this technique, simple as it is, can be very useful for more complicated programs, especially if pretty-printing has to be interleaved with some computational effects. It also helps to achieve good modularity, by "dispatching on the monad type", which helps me to handle two different dialects of SQL with quite good code reuse. But getting to the point... I wonder if such a pattern was used or proposed before. I tried to find some mention of it, but with no luck (or luck :). Most examples of Writer monad use are about logging, etc. If there are no protests, I am going to claim I was the first to use such a technique. It may help me to rescue my poor master's thesis ;) Best regards, Tom -- .signature: Too many levels of symbolic links