Question

Say I want do something for integral types but not chars and I have

is_integral<T>::type and is_char<T>::type

Is it possible to write this:

integral_constant<bool,is::integral<T>::value && !is_char<T>::value>

more readable

Answer 1

Those kinds of metacomputations were done even before C++11 and Boost.MPL is the heavy artillery of TMP in C++03. With it, your requirements can be expressed like so:

// in C++03:
// typedef /* compute */ result;
using result = and_<is_integral<T>, not_<is_char<T>>>;

(Where and_ and not_ are from the boost::mpl namespaces.)

Notice the limited verbosity because you don’t have to put with the ::value boilerplate. Similarly, result is lazy, where you can force computing the result with either result::value (which would be true or false) or result::type (which would be, well, a type — the documentation has all the details). Boost.MPL makes it easy not to do that though, so for instance not_<result> is enough to invert the logic, even though not_<result::type> would also work. A good thing considering that an additoinal typename is needed if result is dependent.

I do consider Boost.MPL of enormous help in C++03 partly because it emulates variadic templates. For instance, and_ is not restricted to two arguments. I’ve shied away from it in C++11 however because in most situations where I used it I now use pack expansion. Things like and_ are still useful though because it is not possible to expand a pack in arbitrary expressions, e.g. in one that involves the && logical operator. This can only be done with a logical metafunction:

// Enforce precondition: every type T must be integral
static_assert( and_<std::is_integral<T>...>::value, "Violation" );

I consider this article a good read that gives good hints to reduce the verbosity of metacomputations. It focuses on SFINAE as used for generic programming but it is applicable to TMP as well (and SFINAE can be used in TMP as well). The final example is

template <typename T,
          EnableIf<is_scalable<T>, is_something_else<T>>...>
T twice(T t) { return 2*t; }

which could look like this in C++03, using facilities similar to those provided in Boost:

template<typename T>
typename enable_if<
    and_<is_scalable<T>, is_something_else<T>>
    , T
>::type twice(T t) { return 2*t; }

A naive C++11 version arguably looks the worst:

template<typename T>
typename std::enable_if<
    is_scalable<T>::value && is_something_else<T>::value
    , T
>::type twice(T t) { return 2*t; }

I’ve seen some that advocate moving away from the style of Boost.MPL, which favours types and type-‘returning’ metafunctions towards using values and constexpr functions. This could look like:

// EnableIf alias now accepts non-type template parameters
template<typename T
         , EnableIf<is_scalable<T>() && is_something_else<T>()>...>
T twice(T t) { return 2*t; }

You’d still need a constexpr function to compute e.g. the logical disjunction if T... is a pack though: EnableIf<any(is_foo<T>()...)>.