pub enum Result<T, E> {
Ok(T),
Err(E),
}
Variants§
Implementations§
source§impl<T, E> Result<T, E>
impl<T, E> Result<T, E>
1.70.0 · sourcepub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool
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);
Runconst: unstable · sourcepub fn as_mut(&mut self) -> Result<&mut T, &mut E>
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);
Run1.41.0 · sourcepub fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U
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);
Run1.41.0 · sourcepub fn map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>(
self,
default: D,
f: F
) -> U
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);
Runsourcepub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T, F>
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()));
Runsourcepub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self
🔬This is a nightly-only experimental API. (result_option_inspect
#91345)
pub fn inspect<F: FnOnce(&T)>(self, f: F) -> Self
result_option_inspect
#91345)sourcepub fn inspect_err<F: FnOnce(&E)>(self, f: F) -> Self
🔬This is a nightly-only experimental API. (result_option_inspect
#91345)
pub fn inspect_err<F: FnOnce(&E)>(self, f: F) -> Self
result_option_inspect
#91345)1.47.0 · sourcepub fn as_deref(&self) -> Result<&T::Target, &E>where
T: Deref,
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
强制转换原始 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);
Run1.47.0 · sourcepub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>where
T: DerefMut,
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
强制转换原始 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);
Runsourcepub fn iter(&self) -> Iter<'_, T> ⓘ
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);
Runsourcepub fn iter_mut(&mut self) -> IterMut<'_, T> ⓘ
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);
Run1.4.0 · sourcepub fn expect(self, msg: &str) -> Twhere
E: Debug,
pub fn expect(self, msg: &str) -> Twhere E: Debug,
返回包含 self
值的包含的 Ok
值。
由于此函数可能为 panic,因此通常不建议使用该函数。
相反,更喜欢使用模式匹配并显式处理 Err
大小写,或者调用 unwrap_or
,unwrap_or_else
或 unwrap_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
模块文档中有关 “常见的消息样式” 的部分。
sourcepub fn unwrap(self) -> Twhere
E: Debug,
pub fn unwrap(self) -> Twhere E: Debug,
返回包含 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);
Run1.16.0 · sourcepub fn unwrap_or_default(self) -> Twhere
T: Default,
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);
Run1.17.0 · sourcepub fn expect_err(self, msg: &str) -> Ewhere
T: Debug,
pub fn expect_err(self, msg: &str) -> Ewhere T: Debug,
sourcepub fn unwrap_err(self) -> Ewhere
T: Debug,
pub fn unwrap_err(self) -> Ewhere T: Debug,
sourcepub fn into_ok(self) -> Twhere
E: Into<!>,
🔬This is a nightly-only experimental API. (unwrap_infallible
#61695)
pub fn into_ok(self) -> Twhere E: Into<!>,
unwrap_infallible
#61695)sourcepub fn into_err(self) -> Ewhere
T: Into<!>,
🔬This is a nightly-only experimental API. (unwrap_infallible
#61695)
pub fn into_err(self) -> Ewhere T: Into<!>,
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}");
Runsourcepub fn and<U>(self, res: Result<U, E>) -> Result<U, E>
pub fn and<U>(self, res: Result<U, E>) -> Result<U, E>
如果结果为 Ok
,则返回 res
; 否则,返回 self
的 Err
值。
传递给 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"));
Runsourcepub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E>
pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E>
如果结果为 Ok
,则调用 op
,否则返回 self
的 Err
值。
该函数可用于基于 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);
Runsourcepub fn or<F>(self, res: Result<T, F>) -> Result<T, F>
pub fn or<F>(self, res: Result<T, F>) -> Result<T, F>
如果结果为 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));
Runsourcepub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F>
pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F>
如果结果为 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));
Runsourcepub fn unwrap_or(self, default: T) -> T
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);
Runsourcepub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T
pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T
1.58.0 · sourcepub unsafe fn unwrap_unchecked(self) -> T
pub unsafe fn unwrap_unchecked(self) -> T
1.58.0 · sourcepub unsafe fn unwrap_err_unchecked(self) -> E
pub unsafe fn unwrap_err_unchecked(self) -> E
source§impl<T, E> Result<Option<T>, E>
impl<T, E> Result<Option<T>, E>
1.33.0 (const: unstable) · sourcepub fn transpose(self) -> Option<Result<T, E>>
pub fn transpose(self) -> Option<Result<T, E>>
将 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);
Runsource§impl<T, E> Result<Result<T, E>, E>
impl<T, E> Result<Result<T, E>, E>
sourcepub fn flatten(self) -> Result<T, E>
🔬This is a nightly-only experimental API. (result_flattening
#70142)
pub fn flatten(self) -> Result<T, E>
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());
RunTrait Implementations§
source§impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E>
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>
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>>>
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
fn from_residual(x: Result<Infallible, E>) -> Self
try_trait_v2
#84277)Residual
类型构造类型。 Read moresource§impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Poll<Result<T, F>>
impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Poll<Result<T, F>>
source§fn from_residual(x: Result<Infallible, E>) -> Self
fn from_residual(x: Result<Infallible, E>) -> Self
try_trait_v2
#84277)Residual
类型构造类型。 Read moresource§impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F>
impl<T, E, F: From<E>> FromResidual<Result<Infallible, E>> for Result<T, F>
source§fn from_residual(residual: Result<Infallible, E>) -> Self
fn from_residual(residual: Result<Infallible, E>) -> Self
try_trait_v2
#84277)Residual
类型构造类型。 Read more1.4.0 · source§impl<'a, T, E> IntoIterator for &'a Result<T, E>
impl<'a, T, E> IntoIterator for &'a Result<T, E>
1.4.0 · source§impl<'a, T, E> IntoIterator for &'a mut Result<T, E>
impl<'a, T, E> IntoIterator for &'a mut Result<T, E>
source§impl<T, E> IntoIterator for Result<T, E>
impl<T, E> IntoIterator for Result<T, E>
source§fn into_iter(self) -> IntoIter<T> ⓘ
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, []);
Runsource§impl<T: PartialOrd, E: PartialOrd> PartialOrd<Result<T, E>> for Result<T, E>
impl<T: PartialOrd, E: PartialOrd> PartialOrd<Result<T, E>> for Result<T, E>
1.16.0 · source§impl<T, U, E> Product<Result<U, E>> for Result<T, E>where
T: Product<U>,
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>>,
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());
Runsource§impl<T, E> Residual<T> for Result<Infallible, E>
impl<T, E> Residual<T> for Result<Infallible, E>
1.16.0 · source§impl<T, U, E> Sum<Result<U, E>> for Result<T, E>where
T: Sum<U>,
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>>,
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"));
Runsource§impl<T, E> Try for Result<T, E>
impl<T, E> Try for Result<T, E>
§type Residual = Result<Infallible, E>
type Residual = Result<Infallible, E>
try_trait_v2
#84277)source§fn from_output(output: Self::Output) -> Self
fn from_output(output: Self::Output) -> Self
try_trait_v2
#84277)Output
类型构造类型。 Read moresource§fn branch(self) -> ControlFlow<Self::Residual, Self::Output>
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>
try_trait_v2
#84277)?
来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue
),还是将一个值传播回调用者 (因为它返回了 ControlFlow::Break
)。 Read more