Musings on TMP and FP

If you've been reading this blog lately you'll see that I've been trying to understand how the Functional Programming Libraries have been implemented by trying to implement one myself. It's more of an excercise for my understanding, more than anything else. It will really be interesting if C++ will get lambda support in the next standard but that's a "wait-and-see" thing. Right now though, I'm trying to understand how you would go about it if you were using the existing language features (like templates, operator overloading, among other things).

Template Metaprogramming (TMP)

I would like to get really deep into the TMP way of doing things first by understanding template specialization and its intricacies. For one, I have observed that it's really tideous if you're out to implement your own TMP algorithms without existing library support like Boost.MPL -- I tried implementing a "max<N,M>" template metafunction, and I quickly saw how it would be an explosion of specializations even just for the first 100 numbers (of course, without library help, what would I expect).

Another observable advantage of doing TMP is the ability to specify behavior during compile time. For instance, your harmless type-deducing operator+ implementation might return an instance of a type which depending on the types of the arguments to the call to operator+, either implement the operator() which takes one argument or two arguments (or none!). There are template patterns such as CRTP (Curiously Recurring Template Pattern) and PBCP (Parametric Base Class Pattern) which are very interesting indeed, and allow for very good and extensible library design.

There's another compelling reason why TMP is something worth learning (for me at least): it allows for writing generic code which can easily be reused in many different contexts without significant and prohibitive performance degradation. The techniques for template metaprogramming also allow for policy-driven components not only in terms of types, but also for behavior.

Functional Programming (FP)

So what has TMP have to do with FP? For one, templates are evaluated recursively by an in-built interpreter (the C++ compiler) in a functional manner -- templates may either take in types or templates and then return concrete types which may then be used as template parameters, which in turn return types which may then be used as template parameters... And in the end, the code produced is valid C++ code.

Let's backtrack a bit here... FP is about using functions that deal with values or functions that return values or functions which in turn can be used as arguments to functions that deal with values or functions that return values or functions... And in the end, the function can be called and used. Do you see a parallelism between FP and TMP? If not yet, you can think about it this way: doing TMP is essentially doing FP albeit in compile time -- types and (static constant) values are immutable, there are no side effects because there are no variables, and the output is either a value (type) or a function (template).

So if TMP is more or less FP, why not bring FP to the user? The obvious answer would be language support. The next would be a matter of convention: most people get introduced to C++ and are told that it's an object oriented language. True enough, but C++ also allows for (among other things) imperative programming, generic programming, and recently functional programming.

So what's the missing link between FP and TMP? A library that's usable enough for everyday programming tasks, and extensible enough for general programming requirements. Some have come close, which I have cited in my post regarding Functional Programming but I would like to see something made part of the standard library.

Synergy

Now with the modern C++ concepts and idioms/practices, it should be feasible to make a fully functional "functional programming library for C++". Techniques for template metaprogramming now allow for generating efficient runtime code, recent improvements in the C++ compiler optimization techniques now make the efficient runtime code from TMP more efficient, and recently a proposal for Lambda functions has been proposed for the next C++ language standard.

All this for the intellectual discourse of a student in C++ programming and learning more about library design. I am excited to think that the concepts I can learn and apply seem endless in this pursuit to understand how Functional Programming in C++ can be enabled, as well as writing truly generic libraries for the community.

Now I go back to hacking.