I’ve recently started exploring the use of std::variant in modern C++ (C++17 and later) to handle errors and return values simultaneously from functions, somewhat similar to Rust’s Result type. I understand the basic usage of std::variant, but I’m looking for efficient and elegant patterns specifically tailored for error handling.

Here is what I’ve tried so far:

#include <iostream>
#include <variant>
#include <string>

using Result = std::variant<std::string, int>;

Result computeValue(int x) {
    if (x < 0) {
        return "Negative input error";
    }
    return x * 2;
}

void handleResult(const Result& result) {
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "Error: " << arg << std::endl;
        } else {
            std::cout << "Computed value: " << arg << std::endl;
        }
    }, result);
}

int main() {
    Result res1 = computeValue(10);
    Result res2 = computeValue(-1);
    handleResult(res1);
    handleResult(res2);
    return 0;
}

I’m currently looking for feedback on the following:

1. Efficiency considerations when using std::variant in this manner.
2. Any potential pitfalls or improvements that can be made to this pattern.
3. How does this approach compare to using exceptions or other traditional error-handling methods in terms of performance and code clarity?

I would appreciate any insights or examples of best practices when using std::variant for error handling.