How do you make the use of std::variants more "palatable", syntax-wise?

Question

This is motivated by an answer I gave a newbie user, where I suggested they use an std::variant instead of a union.

With a union, you may have something like the following:

struct Box {
    struct Item { float value; };
    using Boxes = std::vector<Box>;

    union Value {
        Item item;
        Boxes boxes;
    };

    Value contents;
    std::string label;
};

(not exactly what the original question had, I'm taking some poetic license here.) and with a variant, the class might look like this:

struct Box {
    struct Item { float value; };
    using Boxes = std::vector<Box>;

    std::variant<Item, Boxes> contents;
    std::string label;
};

The thing is, that with the first variant, I can write

if (box.contents.boxes.size() > 2) { foo(); }

and provided that I've already established there are going to be sub-boxes, this will work.

With an std::variant, I have to write:

if (std::get<Boxes>(box.contents).size() > 2) { foo(); }

I feel the second version is much less readable, a bit confusing, and quite distracting. Plus - I have to know the type of boxes.

What can I do, in my code, to spare my users the need to make this kind of std::get() calls, and make their lives more pleasant?

Prefer using `std::visit` instead of `std::get` when accessing `std::variant`s — Mestkon, Jun 12 '20 at 11:32
@Mestkon: Generally, that's valid advice. But suppose I know which is the active type. — einpoklum, Jun 12 '20 at 11:36
The `if` using `std::variant` is not doing the same as the `union` one: it does an unneeded extra check since you have already established there are going to be sub-boxes. Since there is no good way to avoid that check, `std::variant` is not general enough to replace `union`. Thus I avoid recommending it. The compile times, codegen and verbose syntax do not help, either. — Acorn, Jun 12 '20 at 12:37
@Acorn: 1. You're right about the extra check. 2. Theoretically, the compiler can realize, at least in simple cases, that the check is unnecessary and remove it, but I'm not sure that happens in practice. — einpoklum, Jun 12 '20 at 12:48

yuri kilochek · Answer 1 · 2020-06-12T11:47:15.420

5

Just add some accessors wrapping std::gets:

struct Box {
    struct Item { float value; };
    using Boxes = std::vector<Box>;

    std::variant<Item, Boxes> contents;
    std::string label;

    decltype(auto) item()       { return std::get<Item>(contents); }
    decltype(auto) item() const { return std::get<Item>(contents); }

    decltype(auto) boxes()       { return std::get<Boxes>(contents); }
    decltype(auto) boxes() const { return std::get<Boxes>(contents); }
};

And then it goes:

if (box.boxes().size() > 2) { foo(); }

edited Jun 12 '20 at 11:47

answered Jun 12 '20 at 11:41

yuri kilochek

12,709
2
32
59

You'd better make the non-const getters return an lvalue reference, not a copy... but +1. – einpoklum Jun 12 '20 at 12:47
Ah, right, sorry. `decltype(auto)`, need to remember it does that. – einpoklum Jun 12 '20 at 16:37

einpoklum · Answer 2 · 2020-12-17T09:30:25.370

1

How about "visiting" methods? Something like this:

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;


struct Box {
    struct Item { float value; };
    using Boxes = std::vector<Box>;

    std::variant<Item, Boxes> contents;
    std::string label;

    decltype(auto) size() const {
        return std::visit(overloaded {
            [](const Item&)        { return 1; }
            [](const Boxes& boxes) { return boxes.size(); } // non-recursive
        }, *this);
    }
};

and then you write:

if (box.size() > 2 ) { foo(); }

?

edited Dec 17 '20 at 09:30

answered Jun 12 '20 at 12:59

einpoklum

118,144
57
340
684

what exactly is a `const Empty&`? – Patrick Parker Dec 17 '20 at 09:11
@PatrickParker: A copy-paste from something I suggested in the motivating post which shouldn't have carried over into this answer... :-( removed it. – einpoklum Dec 17 '20 at 09:31

How do you make the use of std::variants more "palatable", syntax-wise?

2 Answers2