How to use std::expected in conjunction with std::transform?

Question

I have a flatbuffer. This flatbuffer has a vector<T> that I want to transform using std::transform into a std::vector<U>.

It is possible that T can contain values that are not valid - because they are a plain integer converted to an enum. In this case, I want to abort the whole transform process.

Currently I throw an exception within the lambda of std::transform and catch it in the function that calls the transform function.

std::transform(deserialized_level.rooms.cbegin(), deserialized_level.rooms.cend(), constant_level_data.rooms.begin(),
    [&out_progress, &deserialized_rooms, &deserialized_level](const std::unique_ptr<room_t>& deserialized_room) {
        auto r = room_info{};
        r.position = int3(deserialized_room->position->x, deserialized_room->position->y, deserialized_room->position->z);
        r.sector_width = (unsigned char)(deserialized_room->sector_count_x);
        r.sector_length = (unsigned char)(deserialized_room->sector_count_z);
        auto sector_dimension = sector_size::normal;
        switch(deserialized_room->square_size) {
            case 256:
                sector_dimension = sector_size::smallest;
                break;
            case 512:
                sector_dimension = sector_size::smaller;
                break;
            case 1024:
                sector_dimension = sector_size::normal;
                break;
            case 2048:
                sector_dimension = sector_size::large;
                break;
            case 4096:
                sector_dimension = sector_size::very_large;
                break;
            case 8192:
                sector_dimension = sector_size::huge;
                break;
            case 16384:
                sector_dimension = sector_size::gigantic;
                break;
            default:
                throw std::runtime_error("Unknown sector size detected!" + std::to_string(deserialized_room->square_size));
        }
        //...//
        return r;
});

How would I model this with std::expected? A std::vector<std::expected<T,E>> seems kinda silly.

What's wrong with what you have? Could even parallelise it, while you're at it. — Paul Sanders, Mar 12 '23 at 09:20
Do you wish to continue the transform after the first error or should it break then? — Benjamin Buch, Mar 12 '23 at 11:20
`In this case, I want to abort the whole transform process.` — Raildex, Mar 12 '23 at 11:31

Benjamin Buch · Accepted Answer · 2023-03-12T14:05:47.637

If the transformation is to be aborted at the first unexpected value, an exception in the lambda is the right choice. It is the only way to cancel a std::transform.

What you want as a result is probably std::expected<std::vector<U>, std::string>. To do this, you put the std::transform call into a function that returns a corresponding std::expected.

#include <algorithm>
#include <expected>
#include <string>
#include <vector>

struct room { int size; };
struct room_info { std::string category;};

std::expected<std::vector<room_info>, std::string>
info_of(std::vector<room> const& rooms) try {
    std::vector<room_info> infos;
    infos.reserve(rooms.size());
    std::ranges::transform(rooms, std::back_inserter(infos),
        [](room const& r) -> room_info{
            using namespace std::literals;
            switch(r.size) {
                case 256:
                    return {"smallest"s};
                case 1024:
                    return {"normal"s};
                case 4096:
                    return {"very_large"s};
                case 16384:
                    return {"gigantic"s};
                default:
                    throw "invalid room size"s;
            }
        });
    return infos;
} catch (std::string error) {
    return std::unexpected(std::move(error));
}

Note that you can still throw other exceptions normally. The std::expected here only receives throw's with std::string.

You can use it like this:

#include <iostream>

void print(std::expected<std::vector<room_info>, std::string> const& info) {
    if(info) {
        auto const& list = info.value();
        std::cout << "[";
        if(!list.empty()) {
            std::cout << list[0].category;
            for(std::size_t i = 1; i < list.size(); ++i) {
                std::cout << ", " << list[i].category;
            }
        }
        std::cout << "]\n";
    } else {
        std::cout << info.error() << '\n';
    }
}

int main() {
    print(info_of({{256}, {16384}, {1024}}));
    print(info_of({{256}, {16385}, {1024}}));
}

[smallest, gigantic, normal]
invalid room size

Nothing wrong with any of this per-se, but wouldn't it make sense to allow the exception to propagate up to the point where you want to handle it? — Paul Sanders, Mar 12 '23 at 16:28
@PaulSanders No, you can't say that in general. It depends on how you want to react to the respective problem. Just this example shows very nicely that exceptions and std::expected are orthogonal techniques that can even be used together. Parsing errors occur frequently and are therefore rather processed in the normal control flow. However, the lambda could also throw a bad_alloc. This rarely happens and is therefore rather handled completely via exceptions. — Benjamin Buch, Mar 12 '23 at 20:42
That argument lacks substance. `std::bad_alloc`, in particular, tends to be terminal. — Paul Sanders, Mar 12 '23 at 21:06
@PaulSanders Yes, of course `bad_alloc` is a very bad example. Just assume any other exception. Had named `bad_alloc` only because it is the only other thing that could occur in the above code. But that is simply due to the simplicity of the minimal example. A more complicated transform lambda code may throw other exceptions ;-) — Benjamin Buch, Mar 12 '23 at 21:16

How to use std::expected in conjunction with std::transform?

1 Answers1