Enum core::result::Result

1.0.0 · source ·
pub enum Result<T, E> {
    Ok(T),
    Err(E),
}
Expand description

Result 是代表成功 (Ok) 或失败 (Err) 的类型。

有关详细信息,请参见 模块文档

Variants§

§

Ok(T)

包含成功值

§

Err(E)

包含错误值

Implementations§

source§

impl<T, E> Result<T, E>

const: 1.48.0 · source

pub const fn is_ok(&self) -> bool

如果结果为 Ok,则返回 true

Examples
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
Run
1.70.0 · source

pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool

如果结果是 Ok 并且其中的值与谓词匹配,则返回 true

Examples
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);
Run
const: 1.48.0 · source

pub const fn is_err(&self) -> bool

如果结果为 Err,则返回 true

Examples
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
Run
1.70.0 · source

pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool

如果结果是 Err 并且其中的值与谓词匹配,则返回 true

Examples
use std::io::{Error, ErrorKind};

let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);

let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);

let x: Result<u32, Error> = Ok(123);
assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
Run
source

pub fn ok(self) -> Option<T>

Result<T, E> 转换为 Option<T>

self 转换为 Option<T>,使用 self,并丢弃错误 (如果有)。

Examples
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
Run
source

pub fn err(self) -> Option<E>

Result<T, E> 转换为 Option<E>

self 转换为 Option<E>,使用 self,并丢弃成功值 (如果有)。

Examples
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.err(), None);

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.err(), Some("Nothing here"));
Run
const: 1.48.0 · source

pub const fn as_ref(&self) -> Result<&T, &E>

&Result<T, E> 转换为 Result<&T, &E>

产生一个新的 Result,其中包含对原始引用的引用,并将原始保留在原处。

Examples
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
Run
const: unstable · source

pub fn as_mut(&mut self) -> Result<&mut T, &mut E>

&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);
Run
source

pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E>

通过对包含的 Ok 值应用函数,将 Err 值 Maps 转换为 Result<U, E>,而保持 Err 值不变。

该函数可用于组合两个函数的结果。

Examples

在字符串的每一行上将数字乘以 2 来打印数字。

let line = "1\n2\n3\n4\n";

for num in line.lines() {
    match num.parse::<i32>().map(|i| i * 2) {
        Ok(n) => println!("{n}"),
        Err(..) => {}
    }
}
Run
1.41.0 · source

pub fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U

返回提供的默认值 (如果 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);
Run
1.41.0 · source

pub fn map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>( self, default: D, f: F ) -> 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);
Run
source

pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T, F>

通过对包含的 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()));
Run
source

pub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self

🔬This is a nightly-only experimental API. (result_option_inspect #91345)

使用对包含值的引用调用提供的闭包 (如果 Ok)。

Examples
#![feature(result_option_inspect)]

let x: u8 = "4"
    .parse::<u8>()
    .inspect(|x| println!("original: {x}"))
    .map(|x| x.pow(3))
    .expect("failed to parse number");
Run
source

pub fn inspect_err<F: FnOnce(&E)>(self, f: F) -> Self

🔬This is a nightly-only experimental API. (result_option_inspect #91345)

调用提供的闭包,并引用包含的错误 (如果 Err)。

Examples
#![feature(result_option_inspect)]

use std::{fs, io};

fn read() -> io::Result<String> {
    fs::read_to_string("address.txt")
        .inspect_err(|e| eprintln!("failed to read file: {e}"))
}
Run
1.47.0 · source

pub fn as_deref(&self) -> Result<&T::Target, &E>where T: Deref,

Result<T, E> (或 &Result<T, E>) 转换为 Result<&<T as Deref>::Target, &E>

通过 Deref 强制转换原始 ResultOk 变体,并返回新的 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);
Run
1.47.0 · source

pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>where T: DerefMut,

Result<T, E> (或 &mut Result<T, E>) 转换为 Result<&mut <T as DerefMut>::Target, &mut E>

通过 DerefMut 强制转换原始 ResultOk 变体,并返回新的 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);
Run
source

pub fn iter(&self) -> Iter<'_, T>

返回可能包含的值的迭代器。

如果结果为 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);
Run
source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

返回可能包含的值的可变迭代器。

如果结果为 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);
Run
1.4.0 · source

pub fn expect(self, msg: &str) -> Twhere E: Debug,

返回包含 self 值的包含的 Ok 值。

由于此函数可能为 panic,因此通常不建议使用该函数。 相反,更喜欢使用模式匹配并显式处理 Err 大小写,或者调用 unwrap_orunwrap_or_elseunwrap_or_default

Panics

如果值为 Err,就会出现 panics,其中 panic 消息包括传递的消息以及 Err 的内容。

Examples
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // `Testing expect: emergency failure` 的 panics
Run
推荐的消息样式

我们建议使用 expect 消息来描述您期望 Result 应该是 Ok 的原因。

let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
Run

提示: 如果您无法记住如何表达预期错误消息,请记住将注意力集中在 “should” 上,就像在 “env 变量应该由 blah 设置” 或 “ 给定的二进制文件应该可由当前用户使用和执行“ 中一样。

有关期望消息样式的更多详细信息以及我们建议背后的原因,请参见 std::error 模块文档中有关 “常见的消息样式” 的部分。

source

pub fn unwrap(self) -> Twhere E: Debug,

返回包含 self 值的包含的 Ok 值。

由于此函数可能为 panic,因此通常不建议使用该函数。 相反,更喜欢使用模式匹配并显式处理 Err 大小写,或者调用 unwrap_orunwrap_or_elseunwrap_or_default

Panics

如果该值为 Err,就会出现 Panics,并由 Err 的值提供 panic 消息。

Examples

基本用法:

let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
Run
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // `emergency failure` 的 panics
Run
1.16.0 · source

pub fn unwrap_or_default(self) -> Twhere T: Default,

返回包含的 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);
Run
1.17.0 · source

pub fn expect_err(self, msg: &str) -> Ewhere T: Debug,

返回包含 self 值的包含的 Err 值。

Panics

如果值为 Ok,就会出现 panics,其中 panic 消息包括传递的消息以及 Ok 的内容。

Examples
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // `Testing expect_err: 10` 的 panics
Run
source

pub fn unwrap_err(self) -> Ewhere T: Debug,

返回包含 self 值的包含的 Err 值。

Panics

如果该值为 Ok,则会发生 panic,Ok 的值提供自定义 panic 消息。

Examples
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // `2` 的 panics
Run
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
Run
source

pub fn into_ok(self) -> Twhere E: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible #61695)

返回包含的 Ok 值,但不返回 panics。

unwrap 不同,已知该方法永远不会对其实现的结果类型进行 panic 的处理。 因此,它可以代替 unwrap 用作可维护性保护措施,如果以后将 Result 的错误类型更改为实际可能发生的错误,它将无法编译。

Examples

fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
Run
source

pub fn into_err(self) -> Ewhere T: Into<!>,

🔬This is a nightly-only experimental API. (unwrap_infallible #61695)

返回包含的 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}");
Run
source

pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>

如果结果为 Ok,则返回 res; 否则,返回 selfErr 值。

传递给 and 的参数被热切地评估; 如果要传递函数调用的结果,建议使用 and_then,它是惰性求值的。

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"));
Run
source

pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E>

如果结果为 Ok,则调用 op,否则返回 selfErr 值。

该函数可用于基于 Result 值的控制流。

Examples
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}

assert_eq!(Ok(2).and_then(sq_then_to_string), Ok(4.to_string()));
assert_eq!(Ok(1_000_000).and_then(sq_then_to_string), Err("overflowed"));
assert_eq!(Err("not a number").and_then(sq_then_to_string), Err("not a number"));
Run

通常用于链接可能返回 Err 的错误操作。

use std::{io::ErrorKind, path::Path};

// Note: 在 Windows "/" 映射到 "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
Run
source

pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>

如果结果为 Err,则返回 res; 否则,返回 selfOk 值。

传递给 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));
Run
source

pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F>

如果结果为 Err,则调用 op,否则返回 selfOk 值。

该函数可用于基于结果值的控制流。

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));
Run
source

pub fn unwrap_or(self, default: T) -> T

返回包含的 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);
Run
source

pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T

返回包含的 Ok 值或从闭包中计算得出。

Examples
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
Run
1.58.0 · source

pub unsafe fn unwrap_unchecked(self) -> T

返回包含 self 值的包含的 Ok 值,而不检查该值是否不是 Err

Safety

Err 上调用此方法是 [undefined 行为]

Examples
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
Run
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked(); } // 未定义的行为!
Run
1.58.0 · source

pub unsafe fn unwrap_err_unchecked(self) -> E

返回包含 self 值的包含的 Err 值,而不检查该值是否不是 Ok

Safety

Ok 上调用此方法是 [undefined 行为]

Examples
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // 未定义的行为!
Run
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
Run
source§

impl<T, E> Result<&T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>where T: Copy,

通过复制 Ok 部件的内容,将 Result<&T, E> 的 Maps 转换为 Result<T, E>

Examples
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
Run
1.59.0 · source

pub fn cloned(self) -> Result<T, E>where T: Clone,

通过克隆 Ok 部分的内容,将 Result<&T, E> Maps 转换为 Result<T, E>

Examples
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x, Ok(&12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
Run
source§

impl<T, E> Result<&mut T, E>

1.59.0 · source

pub fn copied(self) -> Result<T, E>where T: Copy,

通过复制 Ok 部件的内容,将 Result<&mut T, E> 的 Maps 转换为 Result<T, E>

Examples
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let copied = x.copied();
assert_eq!(copied, Ok(12));
Run
1.59.0 · source

pub fn cloned(self) -> Result<T, E>where T: Clone,

通过克隆 Ok 部分的内容,将 Result<&mut T, E> Maps 转换为 Result<T, E>

Examples
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x, Ok(&mut 12));
let cloned = x.cloned();
assert_eq!(cloned, Ok(12));
Run
source§

impl<T, E> Result<Option<T>, E>

1.33.0 (const: unstable) · source

pub fn transpose(self) -> Option<Result<T, E>>

OptionResult 转换为 ResultOption

Ok(None) 将映射到 NoneOk(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);
Run
source§

impl<T, E> Result<Result<T, E>, E>

source

pub fn flatten(self) -> Result<T, E>

🔬This is a nightly-only experimental API. (result_flattening #70142)

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());
Run

展平一次只能删除一层嵌套:

#![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());
Run

Trait Implementations§

source§

impl<T, E> Clone for Result<T, E>where T: Clone, E: Clone,

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, source: &Self)

source 执行复制分配。 Read more
source§

impl<T: Debug, E: Debug> Debug for Result<T, E>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
source§

impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E>

source§

fn from_iter<I: IntoIterator<Item = Result<A, E>>>(iter: I) -> Result<V, E>

接受 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]));
Run

这是另一个示例,尝试从另一个整数列表中减去一个,这次检查下溢:

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!"));
Run

这是前一个示例的变体,显示在第一个 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);
Run

由于第三个元素引起下溢,因此不再使用其他元素,因此 shared 的最终值为 6 (= 3 + 2 + 1),而不是 16。

source§

impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Poll<Option<Result<T, F>>>

source§

fn from_residual(x: Result<Infallible, E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
从兼容的 Residual 类型构造类型。 Read more
source§

impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Poll<Result<T, F>>

source§

fn from_residual(x: Result<Infallible, E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
从兼容的 Residual 类型构造类型。 Read more
source§

impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F>

source§

fn from_residual(residual: Result<Infallible, E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
从兼容的 Residual 类型构造类型。 Read more
source§

impl<T, E, F: From<E>> FromResidual<Yeet<E>> for Result<T, F>

source§

fn from_residual(ops::Yeet: Yeet<E>) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
从兼容的 Residual 类型构造类型。 Read more
source§

impl<T: Hash, E: Hash> Hash for Result<T, E>

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

将该值输入给定的 HasherRead more
1.3.0 · source§

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)where Self: Sized,

将这种类型的切片送入给定的 Hasher 中。 Read more
1.4.0 · source§

impl<'a, T, E> IntoIterator for &'a Result<T, E>

§

type Item = &'a T

被迭代的元素的类型。
§

type IntoIter = Iter<'a, T>

我们将其变成哪种迭代器?
source§

fn into_iter(self) -> Iter<'a, T>

从一个值创建一个迭代器。 Read more
1.4.0 · source§

impl<'a, T, E> IntoIterator for &'a mut Result<T, E>

§

type Item = &'a mut T

被迭代的元素的类型。
§

type IntoIter = IterMut<'a, T>

我们将其变成哪种迭代器?
source§

fn into_iter(self) -> IterMut<'a, T>

从一个值创建一个迭代器。 Read more
source§

impl<T, E> IntoIterator for Result<T, E>

source§

fn into_iter(self) -> IntoIter<T>

返回可能包含的值上的消耗迭代器。

如果结果为 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, []);
Run
§

type Item = T

被迭代的元素的类型。
§

type IntoIter = IntoIter<T>

我们将其变成哪种迭代器?
source§

impl<T: Ord, E: Ord> Ord for Result<T, E>

source§

fn cmp(&self, other: &Result<T, E>) -> Ordering

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

将值限制在某个时间间隔内。 Read more
source§

impl<T: PartialEq, E: PartialEq> PartialEq<Result<T, E>> for Result<T, E>

source§

fn eq(&self, other: &Result<T, E>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<T: PartialOrd, E: PartialOrd> PartialOrd<Result<T, E>> for Result<T, E>

source§

fn partial_cmp(&self, other: &Result<T, E>) -> Option<Ordering>

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
source§

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
1.16.0 · source§

impl<T, U, E> Product<Result<U, E>> for Result<T, E>where T: Product<U>,

source§

fn product<I>(iter: I) -> Result<T, E>where I: Iterator<Item = Result<U, E>>,

接受 Iterator 中的每个元素:如果它是 Err,则不再获取其他元素,并返回 Err。 如果没有发生 Err,则返回所有元素的乘积。

Examples

这会将字符串 vector 中的每个数字相乘,如果无法解析字符串,则操作返回 Err:

let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
Run
source§

impl<T, E> Residual<T> for Result<Infallible, E>

§

type TryType = Result<T, E>

🔬This is a nightly-only experimental API. (try_trait_v2_residual #91285)
此元函数的 “return” 类型。
1.16.0 · source§

impl<T, U, E> Sum<Result<U, E>> for Result<T, E>where T: Sum<U>,

source§

fn sum<I>(iter: I) -> Result<T, E>where I: Iterator<Item = Result<U, E>>,

接受 Iterator 中的每个元素:如果它是 Err,则不再获取其他元素,并返回 Err。 如果没有发生 Err,则返回所有元素的总和。

Examples

这将对 vector 中的每个整数求和,如果遇到负元素,则拒绝求和:

let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
Run
source§

impl<T, E> Try for Result<T, E>

§

type Output = T

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
当不短路时,? 产生的值的类型。
§

type Residual = Result<Infallible, E>

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
短路时作为 ? 的一部分传递给 FromResidual::from_residual 的值的类型。 Read more
source§

fn from_output(output: Self::Output) -> Self

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
从它的 Output 类型构造类型。 Read more
source§

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

🔬This is a nightly-only experimental API. (try_trait_v2 #84277)
? 来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue),还是将一个值传播回调用者 (因为它返回了 ControlFlow::Break)。 Read more
source§

impl<T: Copy, E: Copy> Copy for Result<T, E>

source§

impl<T: Eq, E: Eq> Eq for Result<T, E>

source§

impl<T, E> StructuralEq for Result<T, E>

source§

impl<T, E> StructuralPartialEq for Result<T, E>

Auto Trait Implementations§

§

impl<T, E> RefUnwindSafe for Result<T, E>where E: RefUnwindSafe, T: RefUnwindSafe,

§

impl<T, E> Send for Result<T, E>where E: Send, T: Send,

§

impl<T, E> Sync for Result<T, E>where E: Sync, T: Sync,

§

impl<T, E> Unpin for Result<T, E>where E: Unpin, T: Unpin,

§

impl<T, E> UnwindSafe for Result<T, E>where E: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。