Using std::apply on std::expected in C++23

Using std::apply on std::expected in C++23
Using std::apply on std::expected in C++23
Lina Fontaine
Monday, July 22, 2024 at 10:21:46 AM

Streamlining Error Handling in C++23

Effectively handling mistakes and managing return values is essential in today's C++ development. The typical method of working with functions that return {std::expected} types includes a lot of checks and error handling code, which can complicate the logic and make the code more difficult to maintain.

This paper investigates the use of a more sophisticated and general method to simplify error management. In order to reduce boilerplate code and improve readability, we'll investigate constructing a `magic_apply` method that aggregates the results of many {std::expected} values and passes them to another function.

Command Description
std::expected A template type used in C++ for error handling that has the ability to store both values and errors.
std::unexpected When used with std::expected, represents an unexpected error value.
template<typename...> Outlines a variadic template with an infinite amount of template arguments that it can accept.
decltype Used in template programming, especially to find out the type of expression.
args.value() If a std::expected object has a value, accesses the value contained in it.
args.has_value() Verifies whether a value is present in a std::expected object.
(... && args.has_value()) To determine whether every std::expected object has values, fold the expression.
func(args.value()...) Uses the values of the std::expected objects to call the method func.
return unexpected<Err>(args.error()...) Returns an unexpected error containing the errors from the std::expected objects.

Effective Error Management Using Variable Templates

The std::expected type is used in the scripts to ease error handling in C++23. The main goal is to develop a generic function called magic_apply that can transmit the output of several std::expected values to another function. By doing this, the tedious error-checking that is usually necessary when working with many std::expected values is reduced. magic_apply is quite flexible because it may take any number of std::expected parameters by utilizing variadic templates. Before calling the function with the contents of any std::expected object, the fundamental logic of magic_apply employs a fold expression, (... && args.has_value()), to make sure all std::expected objects have valid values.

This idea is illustrated in the first script example using simple types such as int and double. It defines a compute_all function that carries out a basic computation, and getA and getB functions that return std::expected types. If both of the values from getA and getB are legitimate, we can call compute_all using magic_apply; if not, the error is propagated. By reducing boilerplate code, this method enhances readability and maintainability. A similar idea is presented in the second script, but to highlight the approach's versatility, string types and lambda functions are used.

Reducing Complexity in C++ Error Handling with `std::expected}

C++23 Script Using Variadic Templates

#include <expected>
#include <string>
#include <iostream>
#include <tuple>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    if ((... && args.has_value())) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<int, string> getA(int x) {
    if (x > 0) return x;
    return unexpected<string>("Error in getA");
}

expected<double, string> getB(double y) {
    if (y > 0) return y;
    return unexpected<string>("Error in getB");
}

double compute_all(int a, double b) {
    return a + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(10), getB(20.5));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Combining Different {std::expected} Results C++23 values

C++23 Script Using Lambda Functions

#include <expected>
#include <string>
#include <iostream>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    bool all_valid = (args.has_value() && ...);
    if (all_valid) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<string, string> getA(bool flag) {
    if (flag) return "SuccessA";
    return unexpected<string>("Failed A");
}

expected<string, string> getB(bool flag) {
    if (flag) return "SuccessB";
    return unexpected<string>("Failed B");
}

string compute_all(const string& a, const string& b) {
    return a + " and " + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(true), getB(true));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Improving C++ Error Handling with Variadic Templates

The capacity of std::expected to greatly enhance error handling in intricate systems is another crucial benefit of employing it in C++. Combining the results of many asynchronous actions seamlessly is essential in situations when they yield std::expected types. In addition to making the code simpler, this method guarantees strong error handling. More versatile and generic functions can be created by combining an arbitrary number of std::expected values with variadic templates.

The versatility of magic_apply allows it to be used with functions that take in a variety of argument kinds. The implementation is further made simpler by utilizing decltype, which automatically deduces the return type of the combined function call. Furthermore, this technique can be expanded to manage more intricate tasks, including merging std::expected values with other error kinds or altering the values prior to sending them to the function. Because of its adaptability, the pattern can be used for a wide range of tasks, from straightforward computations to complex operations.

Frequently Asked Questions about Variadic Templates and std::expected

  1. What is std::expected?
  2. It is a C++ template type that can hold an error or a valid value and is used for error management.
  3. How does magic_apply work?
  4. It eliminates the need for repeated error checks by combining the results of numerous std::expected values and passing them to a function.
  5. What are variadic templates?
  6. Variable templates offer a large deal of freedom in function design by enabling functions to accept an arbitrary number of parameters.
  7. Why use decltype in magic_apply?
  8. Utilizing the values of the std::expected objects to automatically determine the return type of the function being called.
  9. Is magic_apply capable of handling various error types?
  10. Yes, it can be made to function with std::expected values having various error kinds with a few tweaks.
  11. What advantages does utilizing std::expected offer?
  12. When handling mistakes, it offers a more expressive and cleaner approach than with more conventional techniques like exceptions or return codes.
  13. Is std::unexpected part of std::expected?
  14. In addition to std::expected, std::unexpected does, in fact, represent an incorrect value.
  15. Can asynchronous actions be utilized with magic_apply?
  16. It is indeed adaptable to handle std::expected values returned by asynchronous operations.
  17. What is a fold expression?
  18. Here, the feature in C++ called fold expression is used to check if all std::expected objects contain valid values in a simple manner.

Wrapping Up:

In C++23, implementing a generic function to handle multiple std::expected values greatly improves code readability and greatly simplifies error handling. The magic_apply function reduces boilerplate code and enhances maintainability by using variadic templates to make sure all anticipated values are correct before processing. This method offers a flexible solution that can be applied to different situations and gives modern C++ programming a cleaner, more effective way to handle failures.