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(普通值) | 变换错误类型 |
基本示例
#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) -> U | expected<U, E> |
or_else(f) | 有错误时 | f(E) -> expected<T, G> | expected<T, G> |
transform_error(f) | 有错误时 | f(E) -> G | expected<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 终于将其纳入标准。