The standard leaves (the effect of instantiating) complex<T> for more
general T unspecified.

While we're at it, kill duplicate tests and add long double to the list

We should always export ::Type and ::type to follow
the dune convention and the std pattern for type traits.

This can be used to 'store' an argument pack and access
its members. In contrast to a std::tuple<T...> which is
a container of objects of types T... a TypeList<T...>
only captures the types T... . Hence one can easily
create TypeList objects and use them to pass types around
or. e.g., in overload resolution where they can be used for
tag-dispatch.

This class is e.g. used in the concept checking facility
I'll add soon.

Notice that adding a template packer<T...> doing exactly
the same has been proposed for the standard in N4115

  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4115.html

This is intended to contain everything related to type
computations, like, e.g., type traits, helpers for
overload resolution, ...

The alignof() operator was introduced in C++11.

This allows to give priorities to otherwise ambiguous
overloads. It's main use is to make multiple overloads
work, when only some are ruled out via SFINAE. This is
e.g. used in the concepts check that I'll move to
dune-common soon.

The implemention is trivial but makes such applications
more readable and idiomatic compared to other approaches
where, e.g., null pointers are passed to overloads
have T* and void* dummy arguments.

Due to it's simplicity a separate header may not be justified,
but none of the existing seems to fit.

The warning was added before FS#493 and the related FS#491
were resolved. Probably it was just forgotten to remove the
warning.
I double checked with GCC 5 and -O3. Works for me.

Probably an error caused during merging.

Nothing needs to be included with proper C++11 compilers.

Old feature support macros which were tested until 2.4, kept around
for one more release. As these are now always supported due to the
new compiler requirements, they are directly defined without an
explicit test.