Monadic 操作(and_then / transform / or_else) ​

什么是 Monadic 操作 ​

C++23 为 std::expected 和 std::optional 添加了四个 monadic(单子)操作函数,借鉴自函数式编程。这些函数允许将多个可能失败的操作链式组合,错误会自动沿管道传播,不需要在每一步手动检查。

函数操作对象回调返回类型用途
and_then(f)成功值expected<U, E>链式调用可能失败的操作
transform(f)成功值U(普通值)变换成功值(不会失败)
or_else(f)错误值expected<T, G>尝试从错误恢复
transform_error(f)错误值G(普通值)变换错误类型

基本示例 ​

cpp
#include <iostream>
#include <expected>
#include <string>
#include <charconv>
#include <cmath>

// ============================
// 示例1:and_then——链式可失败操作
// ============================

enum class Error {
    ParseFailed,
    OutOfRange,
    NegativeInput,
    NotFound
};

// 每个函数都可能失败,返回 expected
std::expected<int, Error> parse_number(const std::string& s) {
    int result = 0;
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), result);
    if (ec != std::errc{} || ptr != s.data() + s.size()) {
        return std::unexpected(Error::ParseFailed);
    }
    return result;
}

std::expected<int, Error> validate_range(int value) {
    if (value < 0 || value > 100) {
        return std::unexpected(Error::OutOfRange);
    }
    return value;
}

std::expected<double, Error> compute_sqrt(int value) {
    if (value < 0) {
        return std::unexpected(Error::NegativeInput);
    }
    return std::sqrt(static_cast<double>(value));
}

void and_then_demo() {
    // and_then 链式调用:每一步都可能失败
    // 如果任何一步失败,后续步骤不会执行,错误直接传播
    auto result = parse_number("49")
        .and_then(validate_range)
        .and_then(compute_sqrt);

    if (result) {
        std::cout << "结果: " << *result << std::endl;  // 7
    }

    // 第一步就失败
    auto r2 = parse_number("abc")
        .and_then(validate_range)
        .and_then(compute_sqrt);

    if (!r2) {
        std::cout << "失败: ParseFailed" << std::endl;
    }

    // 第二步失败
    auto r3 = parse_number("200")
        .and_then(validate_range)
        .and_then(compute_sqrt);

    if (!r3) {
        std::cout << "失败: OutOfRange" << std::endl;
    }
}

// ============================
// 示例2:transform——变换成功值
// ============================

void transform_demo() {
    // transform 用于不会失败的变换
    auto result = parse_number("42")
        .transform([](int v) { return v * 2; })           // int -> int
        .transform([](int v) { return std::to_string(v); }) // int -> string
        .transform([](const std::string& s) { return "结果是 " + s; });

    if (result) {
        std::cout << *result << std::endl;  // 结果是 84
    }

    // 失败时 transform 不执行,错误直接传播
    auto r2 = parse_number("xyz")
        .transform([](int v) { return v * 2; });

    if (!r2) {
        std::cout << "transform 没有执行,错误传播" << std::endl;
    }
}

// ============================
// 示例3:or_else——错误恢复
// ============================

std::expected<int, Error> try_default(Error err) {
    // 某些错误可以用默认值恢复
    if (err == Error::NotFound) {
        std::cout << "  使用默认值恢复" << std::endl;
        return 0;  // 恢复成功
    }
    // 其他错误继续传播
    return std::unexpected(err);
}

void or_else_demo() {
    // or_else 在错误时调用,可以尝试恢复
    std::expected<int, Error> not_found = std::unexpected(Error::NotFound);
    auto r1 = not_found.or_else(try_default);

    if (r1) {
        std::cout << "恢复后的值: " << *r1 << std::endl;  // 0
    }

    // 无法恢复的错误
    std::expected<int, Error> parse_err = std::unexpected(Error::ParseFailed);
    auto r2 = parse_err.or_else(try_default);

    if (!r2) {
        std::cout << "无法恢复,错误继续传播" << std::endl;
    }
}

// ============================
// 示例4:transform_error——变换错误类型
// ============================

struct AppError {
    int code;
    std::string message;
};

void transform_error_demo() {
    auto result = parse_number("abc")
        .transform_error([](Error err) -> AppError {
            switch (err) {
                case Error::ParseFailed:
                    return {400, "解析失败"};
                case Error::OutOfRange:
                    return {422, "超出范围"};
                default:
                    return {500, "未知错误"};
            }
        });

    // result 的类型变为 expected<int, AppError>
    if (!result) {
        std::cout << "错误码: " << result.error().code
                  << ", 消息: " << result.error().message << std::endl;
    }
}

// ============================
// 示例5:完整管道——四种操作组合
// ============================

std::expected<std::string, std::string> process_input(const std::string& input) {
    return parse_number(input)
        // 验证范围(可能失败)
        .and_then(validate_range)
        // 计算平方根(可能失败)
        .and_then(compute_sqrt)
        // 格式化结果(不会失败)
        .transform([](double v) {
            return "sqrt = " + std::to_string(v);
        })
        // 转换错误类型为 string
        .transform_error([](Error err) -> std::string {
            switch (err) {
                case Error::ParseFailed: return "输入不是有效数字";
                case Error::OutOfRange: return "数字超出 0-100 范围";
                case Error::NegativeInput: return "不能对负数开方";
                default: return "未知错误";
            }
        })
        // 尝试从错误恢复
        .or_else([](const std::string& err) -> std::expected<std::string, std::string> {
            std::cout << "  记录错误: " << err << std::endl;
            return std::unexpected(err);  // 这里选择不恢复
        });
}

void full_pipeline_demo() {
    std::cout << "--- 成功 ---" << std::endl;
    auto r1 = process_input("49");
    if (r1) std::cout << *r1 << std::endl;

    std::cout << "\n--- 解析失败 ---" << std::endl;
    auto r2 = process_input("abc");
    if (!r2) std::cout << "最终错误: " << r2.error() << std::endl;

    std::cout << "\n--- 范围错误 ---" << std::endl;
    auto r3 = process_input("200");
    if (!r3) std::cout << "最终错误: " << r3.error() << std::endl;
}

// ============================
// 示例6:optional 的 monadic 操作
// ============================

void optional_monadic_demo() {
    std::optional<int> value = 42;
    std::optional<int> empty;

    // and_then:可选值存在时链式调用
    auto r1 = value.and_then([](int v) -> std::optional<double> {
        if (v < 0) return std::nullopt;
        return std::sqrt(v);
    });
    std::cout << "optional and_then: " << r1.value_or(-1) << std::endl;  // 6.48...

    // transform:可选值存在时变换
    auto r2 = value.transform([](int v) { return v * 2; });
    std::cout << "optional transform: " << r2.value_or(-1) << std::endl;  // 84

    // or_else:可选值为空时调用
    auto r3 = empty.or_else([]() -> std::optional<int> {
        return 0;  // 提供默认值
    });
    std::cout << "optional or_else: " << r3.value_or(-1) << std::endl;  // 0
}

int main() {
    std::cout << "=== and_then ===" << std::endl;
    and_then_demo();

    std::cout << "\n=== transform ===" << std::endl;
    transform_demo();

    std::cout << "\n=== or_else ===" << std::endl;
    or_else_demo();

    std::cout << "\n=== transform_error ===" << std::endl;
    transform_error_demo();

    std::cout << "\n=== 完整管道 ===" << std::endl;
    full_pipeline_demo();

    std::cout << "\n=== optional monadic ===" << std::endl;
    optional_monadic_demo();

    return 0;
}

选择哪个操作的决策流程 ​

操作的对象是成功值还是错误值?
|
+-- 成功值
|   |
|   +-- 操作本身可能失败吗?
|       |
|       +-- 是 --> and_then()
|       |         回调返回 expected<U, E>
|       |
|       +-- 否 --> transform()
|                  回调返回普通值 U
|
+-- 错误值
    |
    +-- 想要恢复为成功吗?
        |
        +-- 可能 --> or_else()
        |            回调返回 expected<T, G>
        |
        +-- 否 --> transform_error()
                   回调返回新的错误类型 G

四种操作的详细对比 ​

操作调用条件回调签名结果类型
and_then(f)有值时f(T) -> expected<U, E>expected<U, E>
transform(f)有值时f(T) -> Uexpected<U, E>
or_else(f)有错误时f(E) -> expected<T, G>expected<T, G>
transform_error(f)有错误时f(E) -> Gexpected<T, G>

适用场景 ​

  • 多步验证管道(解析 -> 验证 -> 处理)
  • 数据转换链(类型转换、格式化)
  • 错误类型转换(底层错误 -> 应用层错误)
  • 错误恢复(回退到缓存、使用默认值)
  • 函数式风格的数据处理

常见问题 ​

and_then 和 transform 有什么区别?

and_then 的回调本身返回 expected(操作可能失败),transform 的回调返回普通值(操作不会失败)。如果用 transform 包装一个返回 expected 的函数,会得到 expected<expected<U,E>, E> 的嵌套类型。

管道中任何一步失败,后续会执行吗?

不会。and_then 和 transform 只在成功时执行,失败时直接传播错误。or_else 和 transform_error 只在失败时执行,成功时直接传播值。

optional 也支持这些操作吗?

是的。C++23 同时为 std::optional 添加了 and_then、transform 和 or_else(没有 transform_error,因为 optional 没有错误类型)。

注意事项 ​

  • and_then 的回调必须返回 expected 类型
  • transform 的回调返回普通值,会自动包装为 expected
  • or_else 的回调可以返回成功值来恢复
  • transform_error 只改变错误类型,不改变值类型
  • 管道中错误自动传播,不需要手动检查每一步

总结 ​

Monadic 操作是 C++23 为 std::expected 和 std::optional 添加的函数式链式调用能力。and_then 用于链接可能失败的操作,transform 用于不会失败的值变换,or_else 用于错误恢复,transform_error 用于错误类型转换。四个函数组合起来,可以构建清晰的数据处理管道,错误自动沿管道传播,不需要在每一步手动 if-else 检查。这种风格在 Rust(Result 的 map/and_then)和函数式语言中已经被广泛验证,C++23 终于将其纳入标准。