What you do instead is write functions like the following, which takes an associative list of names and templates and produces a group such that they are able to call one another.

groupStringTemplates :: [(String,StringTemplate)] -> STGroup
groupStringTemplates xs = newGen
    where newGen s = First (M.lookup s ng)
        ng = M.fromList $ map (second $ sgInsert newGen) xs


You’ll notice I’m using a little circular programming hack here too, to set the group of each template as the new group we’re creating, even as we’re still creating the group. It makes the code a little more obscure than necessary, and looking back at it I’m not sure if its actually better or just cuter. Removing the setting of group context entirely, to keep things simple, we get something like (off the top of my head):

groupStringTemplates :: [(String, StringTemplate)] -> STGroup
groupStringTemplates xs = \s -> s = First (M.lookup s myNewMap)
        where myNewMap = M.fromList xs

myNewMap is floated into a where clause so that it only gets evaluated once. We just return the function that wraps the results of its lookup into a First. That’s all there is to it — just return functions directly. addGroups doesn’t need to be written at all. no type instances need to be written at all (well, except for the Functor instance for First, but that’s something that really should be in the standard libs and just isn’t). To add groups g1 and g2 we just write g1 `mappend` g2. It’s hard to see in a way, because thanks to the predefined instances for monoids, everything else comes for free. If someone wants to write a “group” that takes a string and reverses it and then interprets it as perl and returns a StringTemplate built from the result, they just write a function to do just that, and stick First . Just in front of its result. No data declarations, no type declarations, no instances. That function they just wrote is already of the Group type, and for free it can be composed with any other groups of any other sort.

EDIT: Oh, and if you’re asking about what we get with the type before we switch from Maybe to First, the answer above still mainly applies, except we need to write addGroups by hand. However, without the ADTs and typeclasses, we still get away with not needing to write a product type for its result, and we still get away with not needing to write any instance declarations, and we still get away with not needing to write some sort of existential wrapper to avoid an exponential blowup in type signatures or to have multiple groups in a list, etc., and also the need for any class contexts on any functions taking groups as arguments, and suchforth.

Amen, brother! :-). I’m constantly surprised at how often constructs from abstract algebra crop up during day to day programming tasks, as long as you look at those. tasks in the right way.

Thanks for the great post!