So HStringTemplate was built around a simple notion: Everything takes an environment, which is a data structure holding attributes and some other good stuff, and eventually returns a string. This was abstracted later on, but we’ll come back to that. Plan text? That returns a string. A reference to an attribute? It returns a string. A nested template? It returns a string. So when we parse/interpret any template, we end up with a list of functions of type `Env -> String`

. Simple enough to get going with.

So how do we execute this template? We need a function of type `[Env -> String] -> Env -> String.`

If we weren’t thinking functionally, we’d have to write a loop. Create an empty string, and for each function in the list, apply it to our environment, append it to the string, and repeat:

function render(template, env) {
str = "";
foreach (func in template) {
str += func(env);
}
return str;
}

In functional terms we can write (ignoring stack and efficiency issues) a fold:

`render tmp env = foldr (flip (++) . ($ env)) [] tmp`

If we think about it a bit, this is actually `concat $ map ($env) tmp`

, or simpler still `concatMap ($env) tmp`

Step back from the function signature again, and think of it one type at a time and we get an additional abstraction. Instead of `([Env -> String], Env) -> String.`

we can view it as `[Env -> String] -> (Env -> String)`

. But our code doesn’t really represent this, as it explicitly asks for the env parameter. But then again, we could rewrite it as `render tmp = \env -> concatMap ($env) tmp`

, and then pointfreeing the lambda expression we get `(tmp >>=) . flip ($)`

or `(concatMap tmp) . flip ($)`

depending if we want the in this case useless obfuscation of using the list monad.

Good enough, right? Well, imagine that we’ve got our perfect-abstractionometer turned really high for some reason today. There’s a flip and a ($). It looks a bit ugly. It looks a bit obscure. We’ve got compression sure, but not necessarily any more clarity than when we started with. Well, instead of starting from the imperative mindset of how we want this function to work, let’s look at the type signature again and start thinking about what could produce what we’re describing. First, let’s desugar `String`

back to its underlying type, `[Char]`

. That gives us `[Env -> [Char]] -> Env -> [Char]`

. Now since we’re thinking of Env and Char here as abstract atomic types, we can ask, what gives us `[a -> [b]] -> a -> [b]`

? Well, this might be a job for the unwrapped reader monad, since the sequence operation (`Monad m => [m a] -> m [a]`

) resembles what we want. Substitute in (e->) for the m, and we get `[e -> a] -> e -> [a]`

, which in our case becomes `[Env -> [Char]] -> Env -> [[Char]]`

. Almost there! Throw in a concat and we get: `(concat .) . sequence`

of type `[a -> [b]] -> a -> [b]`

. And now, not only is our code short, pointfree, and elegant, but it expresses what we wanted all along more clearly than any previous construct.

And yet.. and yet… some nagging bit of our brain says that this isn’t a compound operation, but an elementary one, for a proper algebra. The only question is what that algebra is. Enter monoids. The Data.Monoid library isn’t extensively documented, but the types almost explain themselves. A monoid is about the simplest algebraic structure that one can imagine. In category theory, a monoid can be viewed as a category with one object.

Ok yeah, but what is it? A monoid is a set of elements, an associative binary operator between them, and an identity element. So, you might have a monoid (Integers,+,0) because + is associative between all integers, and X + 0 = X. Integers also give rise to another monoid: (Integers,*,1). And indeed the Sum and Product monoids are both defined in Data.Monoid. We also get other simple ones for booleans. And, of course, we get, for all a, ([a],++,[]). In fact, the list monoid is also known as the free monoid, essentially because, as best I (sorta) understand it, it comes without any constraints. I.e. if for the integers we have [1,4,2,3] we have “1423” (from the monoid on integers derived by turning them to strings and appending them) and we have 24 from the product monoid and we have 10 from the sum monoid and etc. Thus, the free monoid keeps all information that goes into it, and therefore, so to speak freely arises (without constraints) for any set of objects.

What does all this get us? Well, it gets us generality, especially when we throw higher-order functions back in the mix. In particular, we can now notice that Data.Monoid gives us, for instance the monoid of endomorphisms. So we can conceptually “add” (or rather, mappend), for example, a whole set of functions of type “String -> String” into one big “String -> String” function.

Well, that looks helpful, but it’s not exactly what we want. There is, however, an even cooler Monoid: The reader monoid. `Monoid b => Monoid (a -> b)`

. Conceptually, there’s only one way its mappend function can work: feed the value a into two functions, yielding two bs. Now, given that these bs are, by definition, Monoids as well, we mappend their results.

Along with mappend, which is the associative element, we of course got mconcat for free, which is defined by default as `foldr mappend mempty`

, and as such is the obvious generalization of concat. So now we can look at the type of mconcat specialized to the reader monoid: `Monoid b => [a -> b] -> a -> b`

. And that, ladies and gentlemen, is what we’ve been looking for all along. `(concat .) . sequence`

becomes simply `mconcat`

! Without a lick of coding on our part.

Oh yeah, here’s the icing: we get an even more general type signature. The function as we initially defined it worked for Strings, and by extension, other lists. But it didn’t work for values of, for example, type ShowS (i.e. `String -> String`

, which is a common hack to avoid stack issues with concatenation by encoding strings as functions). But look! Even if ShowS isn’t a list, it is, after all, an endomorphism! And we know by our discussion above endomorphisms are monoids too. And you know what else is a monoid? Oh yeah, a bytestring! And soforth.

I eventually took this idea even further in the HStringTemplate library, and also found another nice use of monoids that I’ll blog about later. The lesson I got out of this though: sometimes, it turns out the simplest abstractions are the most powerful.