Enum std::result::Result 1.0.0[−][src]
pub enum Result<T, E> {
Ok(T),
Err(E),
}Variants
Ok(T)
包含成功值
Err(E)
包含错误值
Implementations
从 &mut Result<T, E> 转换为 Result<&mut T, &mut E>。
Examples
基本用法：
fn mutate(r: &mut Result<i32, i32>) {
match r.as_mut() {
Ok(v) => *v = 42,
Err(e) => *e = 0,
}
}
let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);
let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);返回提供的默认值 (如果 Err)，或者将函数应用于包含的值 (如果 Ok)，
传递给 map_or 的参数会被急切地评估； 如果要传递函数调用的结果，建议使用 map_or_else，它是延迟计算的。
Examples
let x: Result<_, &str> = Ok("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);
let x: Result<&str, _> = Err("bar");
assert_eq!(x.map_or(42, |v| v.len()), 42);1.41.0[src]pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U where
D: FnOnce(E) -> U,
F: FnOnce(T) -> U,
pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U where
D: FnOnce(E) -> U,
F: FnOnce(T) -> U,
通过将 fallback 函数 default 应用于包含的 Err 值，或将函数 f 应用于包含的 Ok 值，将 Result<T, E> 映射为 U。
此函数可用于在处理错误时解压成功的结果。
Examples
基本用法：
let k = 21;
let x : Result<_, &str> = Ok("foo");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);
let x : Result<&str, _> = Err("bar");
assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);通过对包含的 Err 值应用函数，将 Ok 值 Maps 转换为 Result<T, F>，而保持 Ok 值不变。
此函数可用于在处理错误时传递成功的结果。
Examples
基本用法：
fn stringify(x: u32) -> String { format!("error code: {}", x) }
let x: Result<u32, u32> = Ok(2);
assert_eq!(x.map_err(stringify), Ok(2));
let x: Result<u32, u32> = Err(13);
assert_eq!(x.map_err(stringify), Err("error code: 13".to_string()));从 Result<T, E> (或 &Result<T, E>) 转换为 Result<&<T as Deref>::Target, &E>。
通过 Deref 强制转换原始 Result 的 Ok 变体，并返回新的 Result。
Examples
let x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&str, &u32> = Ok("hello");
assert_eq!(x.as_deref(), y);
let x: Result<String, u32> = Err(42);
let y: Result<&str, &u32> = Err(&42);
assert_eq!(x.as_deref(), y);从 Result<T, E> (或 &mut Result<T, E>) 转换为 Result<&mut <T as DerefMut>::Target, &mut E>。
通过 DerefMut 强制转换原始 Result 的 Ok 变体，并返回新的 Result。
Examples
let mut s = "HELLO".to_string();
let mut x: Result<String, u32> = Ok("hello".to_string());
let y: Result<&mut str, &mut u32> = Ok(&mut s);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);
let mut i = 42;
let mut x: Result<String, u32> = Err(42);
let y: Result<&mut str, &mut u32> = Err(&mut i);
assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), y);返回可能包含的值的迭代器。
如果结果为 Result::Ok，则迭代器将产生一个值，否则将不产生任何值。
Examples
基本用法：
let x: Result<u32, &str> = Ok(7);
assert_eq!(x.iter().next(), Some(&7));
let x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter().next(), None);返回可能包含的值的可变迭代器。
如果结果为 Result::Ok，则迭代器将产生一个值，否则将不产生任何值。
Examples
基本用法：
let mut x: Result<u32, &str> = Ok(7);
match x.iter_mut().next() {
Some(v) => *v = 40,
None => {},
}
assert_eq!(x, Ok(40));
let mut x: Result<u32, &str> = Err("nothing!");
assert_eq!(x.iter_mut().next(), None);返回包含 self 值的包含的 Ok 值。
由于此函数可能为 panic，因此通常不建议使用该函数。
相反，更喜欢使用模式匹配并显式处理 Err 大小写，或者调用 unwrap_or，unwrap_or_else 或 unwrap_or_default。
Panics
如果该值为 Err，就会出现 Panics，并由 Err 的值提供 panic 消息。
Examples
基本用法：
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // `emergency failure` 的 panics返回包含的 Ok 值或默认值
然后使用 self 参数，如果 Ok，则返回包含的值，否则如果 Err，则返回该类型的默认值。
Examples
将字符串转换为整数，将格式不正确的字符串转换为 0 (整数的默认值)。
parse 将字符串转换为实现 FromStr 的任何其他类型，并在出错时返回 Err。
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();
assert_eq!(1909, good_year);
assert_eq!(0, bad_year);返回包含的 Err 值，但从不返回 panics。
与 unwrap_err 不同，已知此方法永远不会在其实现的结果类型上使用 panic。
因此，它可以代替 unwrap_err 用作可维护性保障，如果 Result 的 ok 类型稍后更改为实际可以发生的类型，则将无法编译。
Examples
基本用法：
fn only_bad_news() -> Result<!, String> {
Err("Oops, it failed".into())
}
let error: String = only_bad_news().into_err();
println!("{}", error);如果结果为 Ok，则返回 res; 否则，返回 self 的 Err 值。
Examples
基本用法：
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));如果结果为 Ok，则调用 op，否则返回 self 的 Err 值。
该函数可用于基于 Result 值的控制流。
Examples
基本用法：
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
fn err(x: u32) -> Result<u32, u32> { Err(x) }
assert_eq!(Ok(2).and_then(sq).and_then(sq), Ok(16));
assert_eq!(Ok(2).and_then(sq).and_then(err), Err(4));
assert_eq!(Ok(2).and_then(err).and_then(sq), Err(2));
assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));如果结果为 Err，则返回 res; 否则，返回 self 的 Ok 值。
传递给 or 的参数会被急切地评估； 如果要传递函数调用的结果，建议使用 or_else，它是延迟计算的。
Examples
基本用法：
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));
let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));
let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));如果结果为 Err，则调用 op，否则返回 self 的 Ok 值。
该函数可用于基于结果值的控制流。
Examples
基本用法：
fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
fn err(x: u32) -> Result<u32, u32> { Err(x) }
assert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));
assert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));
assert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));
assert_eq!(Err(3).or_else(err).or_else(err), Err(3));返回包含的 Ok 值或提供的默认值。
急切地评估传递给 unwrap_or 的参数； 如果要传递函数调用的结果，建议使用 unwrap_or_else，它是惰性求值的。
Examples
基本用法：
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);
let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);如果结果是包含给定值的 Ok 值，则返回 true。
Examples
#![feature(option_result_contains)]
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains(&2), true);
let x: Result<u32, &str> = Ok(3);
assert_eq!(x.contains(&2), false);
let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains(&2), false);如果结果是包含给定值的 Err 值，则返回 true。
Examples
#![feature(result_contains_err)]
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.contains_err(&"Some error message"), false);
let x: Result<u32, &str> = Err("Some error message");
assert_eq!(x.contains_err(&"Some error message"), true);
let x: Result<u32, &str> = Err("Some other error message");
assert_eq!(x.contains_err(&"Some error message"), false);将 Option 的 Result 转换为 Result 的 Option。
Ok(None) 将映射到 None。
Ok(Some(_)) 和 Err(_) 将映射到 Some(Ok(_)) 和 Some(Err(_))。
Examples
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;
let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);从 Result<Result<T, E>, E> 转换为 Result<T, E>
Examples
基本用法：
#![feature(result_flattening)]
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());
let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());
let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());展平一次只能删除一层嵌套：
#![feature(result_flattening)]
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());如果 self 是 Ok，则返回 Ok 值; 如果 self 是 Err，则返回 Err 值。
换句话说，此函数返回 Result<T, T> 的值 (T)，而不管结果是 Ok 还是 Err。
与 Atomic*::compare_exchange 或 slice::binary_search 等 API 结合使用时，此功能很有用，但仅在您不关心结果是否为 Ok 的情况下才有用。
Examples
#![feature(result_into_ok_or_err)]
let ok: Result<u32, u32> = Ok(3);
let err: Result<u32, u32> = Err(4);
assert_eq!(ok.into_ok_or_err(), 3);
assert_eq!(err.into_ok_or_err(), 4);Trait Implementations
接受 Iterator 中的每个元素：如果它是 Err，则不再获取其他元素，并返回 Err。
如果没有发生 Err，则返回包含每个 Result 值的容器。
这是一个示例，该示例将递增 vector 中的的每个整数，并检查溢出：
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));这是另一个示例，尝试从另一个整数列表中减去一个，这次检查下溢：
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));这是前一个示例的变体，显示在第一个 Err 之后不再从 iter 提取其他元素。
let v = vec![3, 2, 1, 10];
let mut shared = 0;
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| {
shared += x;
x.checked_sub(2).ok_or("Underflow!")
}).collect();
assert_eq!(res, Err("Underflow!"));
assert_eq!(shared, 6);由于第三个元素引起下溢，因此不再使用其他元素，因此 shared 的最终值为 6 (= 3 + 2 + 1)，而不是 16。
impl<T, E, F> FromResidual<Result<Infallible, E>> for Poll<Option<Result<T, F>>> where
F: From<E>,
impl<T, E, F> FromResidual<Result<Infallible, E>> for Poll<Option<Result<T, F>>> where
F: From<E>,
返回可能包含的值上的消耗迭代器。
如果结果为 Result::Ok，则迭代器将产生一个值，否则将不产生任何值。
Examples
基本用法：
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);
let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);type Item = T
type Item = T
被迭代的元素的类型。
如果存在，则此方法返回 self 和 other 值之间的顺序。 Read more
在 ? 来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue)，还是将一个值传播回调用者 (因为它返回了 ControlFlow::Break)。 Read more