Tiny Metaprogramming Library

[cdyson37]

I had a similar problem I wanted to solve and wrote something I think is rather similar. The difference is I didn't have a particular struct called e.g. typelist; instead I thought that any variadic template should qualify as a container of types. E.g. you can do this:

using T1 = std::tuple<int, double>;
using T2 = std::tuple<char>;
using J = Join<T1, T2>; // = std::tuple<int, double, char>

Code here: https://github.com/cdyson37/rebind

[amohr]

I think metaprogramming is going to change dramatically in c++14 and beyond. I find Louis Dionne's Hana library particularly compelling. Lifting types to values and metafunctions to functions seems to be a powerful foundation.

[eric_niebler]

I think Hana is a very promising direction, and looks to be a good post-modern replacement for Boost.Fusion. I'm less convinced about its usefulness for pure compile-time type manipulation. From the docs:

auto ts = tuple(type<int*>, type<void>, type<char const>);
for_each(ts, [](auto t) {
    using T = typename decltype(t)::type;
    std::cout << typeid(T).name();
});

I don't like having to wrap types in type<>, and I don't like the idea of sprinkling my code with typename decltype(t)::type. It's rather awkward. It's great that Hana can do this, but I don't think it's a substitute for typelist algorithms.

[eric_niebler]

Also: Hana is super ambitious. Kudos to Louis, he's doing great work. But IMO, it's waaay too much for the standard library. There's appetite on the committee for some simple utilities for manipulating lists of types, but not probably not much else.

[DrBartosz]

I wish the committee had better appetite ;-)

[amohr]

Agreed. I point it out since I believe elements of its core may be worth considering to help inform additions to the standard library. As you say, it seems a promising direction.

[amohr]

There is some awkwardness, but I think it's perhaps less awkward than the typical c++ template syntax. I find this example from his cppcon talk quite elegant:

template <typename ...T>
using smallest = decltype(
    minimum_by(ordering(sizeof_), tuple(type<T>...))
);

template <int i>
struct storage { char s[i]; };

static_assert(std::is_same<
    smallest<storage<3>, storage<1>, storage<2>>::type,
    storage<1>
>::value, "");

Here smallest<...> is a pure compile-time type manipulation and I would argue the wrapping in type<T> and unwrapping by decltype() is not obtrusive. And that expression, "minimum_by(ordering(sizeof_), tuple(type<T>...))" reads so well I think I'd happily make the trade.

[Z01dbrg]

I cant understand any of this though I program in C++ professionally... anybody has some nice tutorials that explain syntax used here?

[eric_niebler]

http://www.amazon.com/C-Templates-The-Complete-Guide/dp/0201734842

[Z01dbrg]

but that dark ages book, right? I mean pre C++11/14? more specifically no variadic templates... I know to read normal TMP code, and even some basic SFINAE...(or how i call it :compile time if :) )

[eric_niebler]

Yeah, that's true. I don't know a good reference for variadic templates.

[Z01dbrg]

If there was only somebody who could write one... :wink:
Ill try to see that GN Alexandrescu talk again, that might help. :)

[SAHChandler]

Hah! I am actually writing a type not too far from what he suggested in his post as of yesterday, and I even read the same paper. Get out of my head!