template<class R, class...Args>
auto Y = [](auto f) {
  auto action = [](auto f, auto&& action)->std::function<R(Args...)> {
    return [f, action](Args&&...args)mutable ->R{
      return f( action(std::ref(f), action), std::forward<Args>(args)... );
    };
  };
  return action(f, action);
};

Some fun C++ stuff I've done round here:

• A: Convert a run-time value or type to a compile-time value, also works with lists of types.
• A: Named operators, does what it says on the tin
• A: can_apply, a useful trick that helps make traits like "can serialize" or "can convert to string".
• A: task, a move-only implementation of std::function.
• Q: Function curry, that does partial binds and the like.
• A: Me playing around with hana-like metaprogramming, together with the idea that template work best if everything (including templates) is a type. Here is some evil operator abuse, where I manipulate types with +.
• A: std::function that returns vectors of its own type.

Here is a neat question I didn't ask:

• Q: Does SFINAE actually work with class templates?

the answer seems to be "actually, nope, but nobody noticed".

An amusing link:

• http://stackoverflow.com/reputation

which will show your reputation history on stack overflow, if you like that kind of thing.

ey eir em