Re: [boost] [review][mp11] Formal review of Mp11

Subject: Re: [boost] [review][mp11] Formal review of Mp11
From: Brook Milligan (brook_at_[hidden])
Date: 2017-07-19 19:13:14

> On Jul 19, 2017, at 12:41 PM, Zach Laine <whatwasthataddress_at_[hidden]> wrote:
> 
> I've found TMP so *easy* in 11 and later, that I've entirely stop using a library to do it.  I'm trying to understand why anyone would -- that's not my making an argument, just failure of imagination. :)

It is true, that once learned type aliases, variadics, and c++11 make a _huge_ difference in one’s (at least my) ability to simplify metaprogramming.  Thus, a consequence is exactly what you say, lots of individual, one-off little type aliases and such.  In that sense, metaprogramming at one level is now similar to writing lambdas and such.  However, see below ...

> Brook, could you share some example uses?  Is mp11 more useful to you because it does something that would be hard for you to get right, or because it does lots of simple things that you'd have to repeat endlessly?  Or perhaps it's something else?

Sure.  One application that I have found for a more complicated library like Mp11 is the following.  Consider implementing a variadic function like the following:

        template < typename … Parameters >
        auto f (Parameters&& … parameters)
         {
          return detail::f
          (make_parameter_pack
           (make_parameter<tag::first>().default_value(0),
            make_parameter<tag::second>().default_value(1),
            make_parameter<tag::third>().default_value(2)),
           std::forward<Parameters>(parameters)...);
        }

The idea is for detail::f() to take an object that has a variety of constraints (tags, default values, perhaps types) and an arbitrary set of arguments and glue them together into a resulting object that obeys the specified constraints.  Sorting out the set of parameters and matching them against the constraints requires manipulation of lists, sets, and maps of the relevant types.  I found that Mp11 made this fairly straightforward.  I would not have wanted to build the infrastructure to represent and manipulate those data structures myself.  I think this goes well beyond the simple type aliases that I think you are referring to above, but perhaps I misunderstand.

Another application I have found is to allow customization of a set of possible type tags that a library will support.  Using lists of valid tags against which user code can be validated helps support the following: (i) customization of a library to avoid including unwanted code, and (ii) validating user code against the current configuration of the library.  Again, this involves manipulating metaprogramming data structures, not simply evaluating metafunctions.

So, to me the value of something like Mp11 is that it provides some basic metaprogramming data structures, i.e., list, set, and map, along with the generic means of manipulating them.  I think that is quite different from the “easy” metaprogramming you may be referring to.  On the other hand, perhaps metaprogramming is much more transparent to you than to me, and you feel that managing a map in a nice generic way is “easy”.

Cheers,
Brook