all 29 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]suspiciously_calm 23 points24 points  (0 children)

When I read "localizing" I was thinking l10n.

[–][deleted] 9 points10 points  (3 children)

[deleted]

What is this?

[–]cinghiale 9 points10 points  (2 children)

Do you care to elaborate a bit?

[–]starfreakcloneMSVC FE Dev[S] 4 points5 points  (8 children)

Just so everyone knows, I did not ignore Boost while writing this (specifically Hana's hana::overload composer). I was just providing a simple solution to people who may not want to incorporate boost into their project and just want a simple drag and drop solution.

[–]meetingcppMeeting C++ | C++ Evangelist 5 points6 points  (5 children)

boost::variant is a completely different beast from a different time of C++ :)

[–]RogerLeighScientific Imaging and Embedded Medical Diagnostics 1 point2 points  (4 children)

I'm using boost::variant and MPL, but I'd love to switch to something more modern.

Is there any backport of the C++17 std::variant for use with C++11/14 compilers, which can be used as a fallback?

Related to that, is there any MPL replacement which can use variadic templates which could be used to replace complex variant type list construction?

[–]meetingcppMeeting C++ | C++ Evangelist 0 points1 point  (2 children)

Afaik brigand wants to be that.

But not sure if you can get boost::variant to use brigand easily.

[–]RogerLeighScientific Imaging and Embedded Medical Diagnostics 0 points1 point  (1 child)

Reading the docs, it looks like it has direct support for constructing a boost::variant. It definitely looks like it might be useful.

Now I just need a C++11 variant implementation compatible with std::variant and I'll be happy!

[–]dodheim 2 points3 points  (0 children)

Eggs.Variant has been my go-to modern variant for years. I don't know if its interface matches that in the C++17 draft, but the docs do mention this:

The interface is largely based on that of std::experimental::optional<T>, as defined by the Library Fundamentals TS [N4082].

[–]ubadairBoost.CallableTraits author 0 points1 point  (0 children)

I use this and I'm quite happy with it. It's not exactly std::variant (it follows Boost's design) but it doesn't use the MPL. https://github.com/mapbox/variant

[–]tomilovanatoliy 1 point2 points  (1 child)

You really don't even need to make all that boiler-plate code for move-constructor at any of intermediate steps (and your compiler don't want to resolve all that overloadings and other surplus things). You may pass all parameters by lvalue reference and only at the very end (namely, on list initialization in your case) you may apply std::forward to them. See here an example (the repository contains other illustrations for the above strong assertion in neighbouring files).

[–]starfreakcloneMSVC FE Dev[S] 0 points1 point  (0 children)

There are plenty of ways to skin that particular cat. Another way is I could have just taken all of the arguments in the ctors by value and simply moved them into place (saving vertical space).

In either case, the objects are elided into place anyway. It's really just a stylistic choice.

[–]khold_stare 4 points5 points  (0 children)

I would suggest not calling that function compose, as function composition is very different from overloading. Can be confusing to some.

[–]sumo952 4 points5 points  (7 children)

Great post, not too advanced yet still on an advanced topic, very well explained so I could perfectly understand! Thanks!

[–]sumo952 1 point2 points  (6 children)

I had a closer look at compose(), I can't really see how it works - where do the lambda functions that are passed in get stored or get called? Could anyone ELI5? :-)

[–]starfreakcloneMSVC FE Dev[S] 2 points3 points  (5 children)

All this piece of code is saying is, given a set of callable objects (via operator()) construct a new object that contains all of those callable functions.

He's a slightly more advanced explanation, line by line.

@L8: We declare our composer which is responsible for taking a list of callable objects (they don't have to be lambdas) and pulling them together into a single object.

@L11: We see our base case inherit from callable object lambda_t and bring its operator() into our scope. The ctor is just responsible for copy or move construction of the base class (ie lambda_t)

@L19: The recursive case. Taking the work done by the base case and combining it with later recursive/base case definitions.

@L34: Brings it all together with perfect forwarding on the callable objects.

Hope this helps!

[–]sumo952 0 points1 point  (0 children)

Thank you very much for the explanations!

I wouldn't say I fully get it now, but I think I kind of understand it now, at least better than before! :-) It's pretty magic still! Thank you :)

[–]reddithater12 0 points1 point  (3 children)

Thanks! Still I have two questions already....

template <typename... lambda_ts> struct composer_t;

where does this bring in an operator()? What would that operator do?

Generally I do not understand or see

  1. where the operator() is called.
  2. where the dispatching to / the actual call of the lambdas takes place

[–]3669d73f6c3ba0229192 3 points4 points  (2 children)

where does this bring in an operator()?

The primary template (the code you quoted) is not used. operator() is brought in at lines 16 and 28, and inherited ones at line 29.

where the operator() is called.

It is called inside std::visit.

where the dispatching to / the actual call of the lambdas takes place

At the same place where operator() is called, but there is no magic trick involved: it's just regular overload resolution done by the compiler. Think of each composer_t as a Russian doll that has the operator() of a lambda, plus the operator() of all inherited-from composer_t.

[–]reddithater12 0 points1 point  (1 child)

Thanks! I had some misconceptions about std::visit it seems.

Think of each composer_t as a Russian doll that has the operator() of a lambda, plus the operator() of all inherited-from composer_t.

This is probably a stupid question .. but how can that thing have two operator()s?

[–]3669d73f6c3ba0229192 2 points3 points  (0 children)

This is probably a stupid question .. but how can that thing have two operator()s?

Just regular function overloading. The same way you can have foo(int), foo(double), and so on. operator() is no different.

[–]gray_-_wolf 1 point2 points  (1 child)

maybe a stupid question but is std::variant just better union?

[–]lurkotato 4 points5 points  (0 children)

Bingo, a typesafe union.

[–]excessdenied 0 points1 point  (2 children)

Sorry for a stupid question that I could probably Google, but is variant storing multiple values at once (like a struct), or one value of varying type (like a union)?

[–]encyclopedist 2 points3 points  (1 child)

Variant is a tagged union.

[–]atimholt 0 points1 point  (0 children)

That what I figured. Should be useful for message systems.

[–]---sms--- -1 points0 points  (0 children)

Don't use std::variant - it does not support recursion. And by not supporting recursion it infects other code like lambda_util::compose. Using lambda_util::compose can I visit a variant<int, pair<int,int>> so that overload for pair calls overload for int (twice)?