Rust从入门到实战系列三百零七：map & and_then

map and and_then 是两个常用的组合器( combinator )，可以用于 Result<T, E> (也可用于
Option ).
4. 🌟🌟
use std::num::ParseIntError;
// 使 用 两 种 方 式 填 空: map, and then
fn add_two(n_str: &str) -> Result<i32, ParseIntError> {
n_str.parse::().__
}
fn main() {
assert_eq!(add_two(“4”).unwrap(), 6);
println!(“Success!”)
}
5. 🌟🌟🌟
use std::num::ParseIntError;
// 使 用 Result 重 写 后 ， 我 们 使 用 模 式 匹 配 的 方 式 来 处 理 ， 而 无 需 使 用 unwrap
// 但 是 这 种 写 法 实 在 过 于 啰 嗦…
fn multiply(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
match n1_str.parse::() {
Ok(n1) => {
match n2_str.parse::() {
Ok(n2) => {
Ok(n1 * n2)
},
Err(e) => Err(e),
}
},
Err(e) => Err(e),
}
}
// 重 写 上 面 的 multiply ， 让 它 尽 量 简 介
// 提 示 ： 使 用 and_then 和 map
fn multiply1(n1_str: &str, n2_str: &str) -> Result<i32, ParseIntError> {
// 实 现…
}
fn print(result: Result<i32, ParseIntError>) {
match result {
Ok(n) => println!(“n is {}”, n),
Err(e) => println!(“Error: {}”, e),
}
}
fn main() {
let twenty = multiply1(“10”, “2”);
print(twenty);
// 下 面 的 调 用 会 提 供 更 有 帮 助 的 错 误 信 息
let tt = multiply(“t”, “2”);
print(tt);
println!(“Success!”)
}
类型别名
如果我们要在代码中到处使用 std::result::Result<T, ParseIntError> ，那毫无疑问，代码将变得特
别冗长和啰嗦，对于这种情况，可以使用类型别名来解决。
例如在标准库中，就在大量使用这种方式来简化代码: io::Result .
6. 🌟
use std::num::ParseIntError;
// 填 空
type __;
// 使 用 上 面 的 别 名 来 引 用 原 来 的 Result 类 型
fn multiply(first_number_str: &str, second_number_str: &str) -> Res {
first_number_str.parse::().and_then(|first_number| {
second_number_str.parse::().map(|second_number| first_number * second_number
})
}
// 同 样, 这 里 也 使 用 了 类 型 别 名 来 简 化 代 码
fn print(result: Res) {
match result {
Ok(n) => println!(“n is {}”, n),
Err(e) => println!(“Error: {}”, e),
}
}
fn main() {
print(multiply(“10”, “2”));
print(multiply(“t”, “2”));
println!(“Success!”)
}