Alternative to bad_variant_access

[jcelerier]

Hello,

Do you think that it would be possible to have an alternative to the current apply mechanism, which would call an operator()() with no arguments instead of throwing ?

A bit like this (but without the overhead of try...catch) :

template<typename Visitor, typename... Variants>
auto apply_noexcept(Visitor&& v, Variants&&... vars) noexcept
    -> decltype(auto)
{
    try {
        return eggs::variants::apply(v, std::forward<Variants>(vars)...);
    }
    catch(const eggs::variants::bad_variant_access& e) {
        return v();
    }
}


int main() 
{
    eggs::variant<int, float> var;
    struct vis {
            int operator()(int) { return 0; }
            int operator()(float) { return 1; }
            int operator()() { return 2; }
    } v;

    auto res = apply_noexcept(v, var);
    assert(res == 2);
}

This is because sometimes types have a meaningful "null" value, and I find it better to just use the variant's null state, than make a variant<some_null_type, ...>.

[K-ballo]

I don't think it would be possible in the form presented here. While it looks somewhat sensible for the unary visitation case, it fails to extend to multivisitation. Consider:

eggs::variant<int> v1 = /*...*/, v2 = /*...*/;
struct vis {
  int operator()() { /*...*/ } // both empty
  int operator()(int) { /*...*/ } // one empty, but which one?
  int operator()(int, int) { /*...*/ }
} vis;

apply_noexcept(vis, v1, v2);

What we would need here is something that maps the empty state to an empty type, so that it can be leveraged by overload resolution. I don't think that's a job for apply though, but rather for some sort of variant adaptor. Such adaptor would exhibit behavior similar to that of boost::variant<boost::blank, Ts...>, where the variant is never empty because it will happily revert to a default constructed dummy type on failure.

Perhaps this is a simpler solution to your needs:

template <typename Visitor, typename Variant>
decltype(auto) apply_nothrow(Visitor&& v, Variant&& var)
{
  if (var) {
    return eggs::variants::apply(
        std::forward<Visitor>(v), std::forward<Variant>(var));
  } else {
    return std::forward<Visitor>(v)();
  }
}

Thoughts?

[jcelerier]

Yes, it makes sense ! I didn't know that multi-visitation was even possible :p
Thanks for the snippet.