Enum core::option::Option1.0.0[−][src]

pub enum Option<T> {
    None,
    Some(T),
}

Expand description

Option 类型。有关更多信息，请参见模块级文档。

Variants

None

没有值

Some(T)

一些值 T

Implementations

impl<T> Option<T>

[src]

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]
pub const fn is_some(&self) -> bool

1.0.0 (const: 1.48.0)[src]

如果选项是 Some 值，则返回 true。

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

Run

#[must_use = "if you intended to assert that this doesn't have a value, consider \ `.and_then(|_| panic!(\"`Option` had a value when expected `None`\"))` instead"]
pub const fn is_none(&self) -> bool

1.0.0 (const: 1.48.0)[src]

如果选项是 None 值，则返回 true。

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

Run

#[must_use]
pub fn contains(&self, x: &U) -> bool where
U: PartialEq<T>,

[src]

🔬 This is a nightly-only experimental API. (option_result_contains #62358)

如果选项是包含给定值的 Some 值，则返回 true。

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

Run

pub const fn as_ref(&self) -> Option<&T>

1.0.0 (const: 1.48.0)[src]

从 &Option<T> 转换为 Option<&T>。

Examples

将 Option<String> 转换为 Option<usize>，并保留原始格式。 map 方法按值使用 self 参数，从而消耗了原始文件，因此该技术使用 as_ref 首先将 Option 引用给原始文件中的值。

let text: Option<String> = Some("Hello, world!".to_string());
// 首先，使用 `as_ref` 将 `Option<String>` 转换为 `Option<&String>`，然后使用 `map` 消耗 *that*，将 `text` 保留在栈中。
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

Run

pub fn as_mut(&mut self) -> Option<&mut T>

[src]

从 &mut Option<T> 转换为 Option<&mut T>。

Examples

let mut x = Some(2);
match x.as_mut() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

Run

pub fn as_pin_ref(self: Pin<&Self>) -> Option<Pin<&T>>

1.33.0 [src]

从 Pin<&Option<T>> 转换为 Option<Pin<&T>>。

pub fn as_pin_mut(self: Pin<&mut Self>) -> Option<Pin<&mut T>>

1.33.0 [src]

从 Pin<&mut Option<T>> 转换为 Option <Pin<&mut T>>。

pub fn expect(self, msg: &str) -> T

[src]

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

Panics

Panics (如果值是具有 msg 提供的自定义 panic 消息的 None)。

Examples

let x = Some("value");
assert_eq!(x.expect("fruits are healthy"), "value");

Run

let x: Option<&str> = None;
x.expect("fruits are healthy"); // `fruits are healthy` 的 panics

Run

pub fn unwrap(self) -> T

[src]

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

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

Panics

如果自身值等于 None，则为 Panics。

Examples

let x = Some("air");
assert_eq!(x.unwrap(), "air");

Run

let x: Option<&str> = None;
assert_eq!(x.unwrap(), "air"); // fails

Run

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

[src]

返回包含的 Some 值或提供的默认值。

急切地评估传递给 unwrap_or 的参数; 如果要传递函数调用的结果，建议使用 unwrap_or_else，它是惰性求值的。

Examples

assert_eq!(Some("car").unwrap_or("bike"), "car");
assert_eq!(None.unwrap_or("bike"), "bike");

Run

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

[src]

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

Examples

let k = 10;
assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);
assert_eq!(None.unwrap_or_else(|| 2 * k), 20);

Run

pub unsafe fn unwrap_unchecked(self) -> T

[src]

🔬 This is a nightly-only experimental API. (option_result_unwrap_unchecked #81383)

newly added

返回包含 self 值的包含的 Some 值，而不检查该值是否不是 None。

Safety

在 None 上调用此方法是 undefined behavior。

Examples

#![feature(option_result_unwrap_unchecked)]
let x = Some("air");
assert_eq!(unsafe { x.unwrap_unchecked() }, "air");

Run

#![feature(option_result_unwrap_unchecked)]
let x: Option<&str> = None;
assert_eq!(unsafe { x.unwrap_unchecked() }, "air"); // 未定义的行为!

Run

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option

[src]

通过将函数应用于包含的值，Maps 将 Option<T> 转换为 Option。

Examples

使用原始文件将 Option<String> 转换为 Option<usize>:

let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` 需要 self 按照值消耗 `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|s| s.len());

assert_eq!(maybe_some_len, Some(13));

Run

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

[src]

返回提供的默认结果 (如果没有)，或将函数应用于包含的值 (如果有)。

急切地评估传递给 map_or 的参数; 如果要传递函数调用的结果，建议使用 map_or_else，它是延迟计算的。

Examples

let x = Some("foo");
assert_eq!(x.map_or(42, |v| v.len()), 3);

let x: Option<&str> = None;
assert_eq!(x.map_or(42, |v| v.len()), 42);

Run

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

[src]

计算 default 函数的结果 (如果没有)，或将不同的函数应用于包含的值 (如果有)。

Examples

let k = 21;

let x = Some("foo");
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);

let x: Option<&str> = None;
assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);

Run

pub fn ok_or<E>(self, err: E) -> Result<T, E>

[src]

将 Option<T> 转换为 Result<T, E>，将 Some(v) 映射到 Ok(v)，将 None 映射到 Err(err)。

急切地评估传递给 ok_or 的参数; 如果要传递函数调用的结果，建议使用 ok_or_else，它是延迟计算的。

Examples

let x = Some("foo");
assert_eq!(x.ok_or(0), Ok("foo"));

let x: Option<&str> = None;
assert_eq!(x.ok_or(0), Err(0));

Run

pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E>

[src]

将 Option<T> 转换为 Result<T, E>，将 Some(v) 映射到 Ok(v)，将 None 映射到 Err(err())。

Examples

let x = Some("foo");
assert_eq!(x.ok_or_else(|| 0), Ok("foo"));

let x: Option<&str> = None;
assert_eq!(x.ok_or_else(|| 0), Err(0));

Run

pub fn iter(&self) -> Iter<'_, T>ⓘ
Notable traits for Iter<'a, A>
`impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;`

[src]

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

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

Run

pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
Notable traits for IterMut<'a, A>
`impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;`

[src]

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

Examples

let mut x = Some(4);
match x.iter_mut().next() {
    Some(v) => *v = 42,
    None => {},
}
assert_eq!(x, Some(42));

let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);

Run

pub fn and(self, optb: Option) -> Option

[src]

如果选项为 None，则返回 None; 否则，返回 optb。

Examples

let x = Some(2);
let y: Option<&str> = None;
assert_eq!(x.and(y), None);

let x: Option<u32> = None;
let y = Some("foo");
assert_eq!(x.and(y), None);

let x = Some(2);
let y = Some("foo");
assert_eq!(x.and(y), Some("foo"));

let x: Option<u32> = None;
let y: Option<&str> = None;
assert_eq!(x.and(y), None);

Run

pub fn and_then<U, F: FnOnce(T) -> Option>(self, f: F) -> Option

[src]

如果选项为 None，则返回 None; 否则，使用包装的值调用 f，并返回结果。

一些语言调用此操作平面图。

Examples

fn sq(x: u32) -> Option<u32> { Some(x * x) }
fn nope(_: u32) -> Option<u32> { None }

assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
assert_eq!(Some(2).and_then(sq).and_then(nope), None);
assert_eq!(Some(2).and_then(nope).and_then(sq), None);
assert_eq!(None.and_then(sq).and_then(sq), None);

Run

pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Self

1.27.0 [src]

如果选项为 None，则返回 None; 否则，使用包装的值调用 predicate 并返回:

Some(t) 如果 predicate 返回 true (其中 t 是包装的值)，并且
None 如果 predicate 返回 false。

该函数的工作方式类似于 Iterator::filter()。您可以想象 Option<T> 是一个或零个元素上的迭代器。 filter() 让您决定要保留哪些元素。

Examples

fn is_even(n: &i32) -> bool {
    n % 2 == 0
}

assert_eq!(None.filter(is_even), None);
assert_eq!(Some(3).filter(is_even), None);
assert_eq!(Some(4).filter(is_even), Some(4));

Run

pub fn or(self, optb: Option<T>) -> Option<T>

[src]

如果包含值，则返回选项，否则返回 optb。

急切地评估传递给 or 的参数; 如果要传递函数调用的结果，建议使用 or_else，它是延迟计算的。

Examples

let x = Some(2);
let y = None;
assert_eq!(x.or(y), Some(2));

let x = None;
let y = Some(100);
assert_eq!(x.or(y), Some(100));

let x = Some(2);
let y = Some(100);
assert_eq!(x.or(y), Some(2));

let x: Option<u32> = None;
let y = None;
assert_eq!(x.or(y), None);

Run

pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T>

[src]

如果选项包含值，则返回该选项，否则调用 f 并返回结果。

Examples

fn nobody() -> Option<&'static str> { None }
fn vikings() -> Option<&'static str> { Some("vikings") }

assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians"));
assert_eq!(None.or_else(vikings), Some("vikings"));
assert_eq!(None.or_else(nobody), None);

Run

pub fn xor(self, optb: Option<T>) -> Option<T>

1.37.0 [src]

如果 self，optb 之一恰好是 Some，则返回 Some，否则返回 None。

Examples

let x = Some(2);
let y: Option<u32> = None;
assert_eq!(x.xor(y), Some(2));

let x: Option<u32> = None;
let y = Some(2);
assert_eq!(x.xor(y), Some(2));

let x = Some(2);
let y = Some(2);
assert_eq!(x.xor(y), None);

let x: Option<u32> = None;
let y: Option<u32> = None;
assert_eq!(x.xor(y), None);

Run

#[must_use = "if you intended to set a value, consider assignment instead"]
pub fn insert(&mut self, value: T) -> &mut T

1.53.0 [src]

将 value 插入选项，然后向其返回变量引用。

如果该选项已包含值，则将丢弃旧值。

另请参见 Option::get_or_insert，如果选项已包含 Some，则不会更新值。

Example

let mut opt = None;
let val = opt.insert(1);
assert_eq!(*val, 1);
assert_eq!(opt.unwrap(), 1);
let val = opt.insert(2);
assert_eq!(*val, 2);
*val = 3;
assert_eq!(opt.unwrap(), 3);

Run

pub fn get_or_insert(&mut self, value: T) -> &mut T

1.20.0 [src]

如果为 None，则将 value 插入到选项中，然后返回所包含的值的变量引用。

另请参见 Option::insert，即使选项已包含 Some，它也会更新值。

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert(5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

Run

pub fn get_or_insert_default(&mut self) -> &mut T where
T: Default,

[src]

🔬 This is a nightly-only experimental API. (option_get_or_insert_default #82901)

如果默认值为 None，则将其插入选项中，然后将所包含的值返回变量引用。

Examples

#![feature(option_get_or_insert_default)]

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_default();
    assert_eq!(y, &0);

    *y = 7;
}

assert_eq!(x, Some(7));

Run

pub fn get_or_insert_with<F: FnOnce() -> T>(&mut self, f: F) -> &mut T

1.20.0 [src]

如果从 f 计算得出的值是 None，则将其插入选项中，然后将所包含的值返回可变引用。

Examples

let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_with(|| 5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));

Run

pub fn take(&mut self) -> Option<T>

[src]

从选项中取出值，将 None 留在其位置。

Examples

let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);

Run

pub fn replace(&mut self, value: T) -> Option<T>

1.31.0 [src]

用参数中给定的值替换选项中的实际值，如果存在则返回旧值，将 Some 保留在其位置，而不用对其中一个进行初始化。

Examples

let mut x = Some(2);
let old = x.replace(5);
assert_eq!(x, Some(5));
assert_eq!(old, Some(2));

let mut x = None;
let old = x.replace(3);
assert_eq!(x, Some(3));
assert_eq!(old, None);

Run

pub fn zip(self, other: Option) -> Option<(T, U)>

1.46.0 [src]

用另一个 Option 压缩 self。

如果 self 是 Some(s)，而 other 是 Some(o)，则此方法返回 Some((s, o))。否则，返回 None。

Examples

let x = Some(1);
let y = Some("hi");
let z = None::<u8>;

assert_eq!(x.zip(y), Some((1, "hi")));
assert_eq!(x.zip(z), None);

Run

pub fn zip_with<U, F, R>(self, other: Option, f: F) -> Option<R> where
F: FnOnce(T, U) -> R,

[src]

🔬 This is a nightly-only experimental API. (option_zip #70086)

使用函数 f 压缩 self 和另一个 Option。

如果 self 是 Some(s)，而 other 是 Some(o)，则此方法返回 Some(f(s, o))。否则，返回 None。

Examples

#![feature(option_zip)]

#[derive(Debug, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}

let x = Some(17.5);
let y = Some(42.7);

assert_eq!(x.zip_with(y, Point::new), Some(Point { x: 17.5, y: 42.7 }));
assert_eq!(x.zip_with(None, Point::new), None);

Run

impl<T: Copy> Option<&T>

[src]

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

1.35.0 [src]

通过复制选项的内容将 Option<&T> 的 Maps 转换为 Option<T>。

Examples

let x = 12;
let opt_x = Some(&x);
assert_eq!(opt_x, Some(&12));
let copied = opt_x.copied();
assert_eq!(copied, Some(12));

Run

impl<T: Copy> Option<&mut T>

[src]

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

1.35.0 [src]

通过复制选项的内容将 Option<&mut T> 的 Maps 转换为 Option<T>。

Examples

let mut x = 12;
let opt_x = Some(&mut x);
assert_eq!(opt_x, Some(&mut 12));
let copied = opt_x.copied();
assert_eq!(copied, Some(12));

Run

impl<T: Clone> Option<&T>

[src]

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

[src]

通过克隆选项的内容将 Option<&T> Maps 转换为 Option<T>。

Examples

let x = 12;
let opt_x = Some(&x);
assert_eq!(opt_x, Some(&12));
let cloned = opt_x.cloned();
assert_eq!(cloned, Some(12));

Run

impl<T: Clone> Option<&mut T>

[src]

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

1.26.0 [src]

通过克隆选项的内容将 Option<&mut T> Maps 转换为 Option<T>。

Examples

let mut x = 12;
let opt_x = Some(&mut x);
assert_eq!(opt_x, Some(&mut 12));
let cloned = opt_x.cloned();
assert_eq!(cloned, Some(12));

Run

impl<T: Default> Option<T>

[src]

pub fn unwrap_or_default(self) -> T

[src]

返回包含的 Some 值或默认值

消费 self 参数，如果 Some，则返回所包含的值，否则，如果 None，则返回该类型的 default value。

Examples

将字符串转换为整数，将格式不正确的字符串转换为 0 (整数的默认值)。 parse 将字符串转换为实现 FromStr 的任何其他类型，并在错误时返回 None。

let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().ok().unwrap_or_default();
let bad_year = bad_year_from_input.parse().ok().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);

Run

impl<T: Deref> Option<T>

[src]

pub fn as_deref(&self) -> Option<&T::Target>

1.40.0 [src]

从 Option<T> (或 &Option<T>) 转换为 Option<&T::Target>。

将原始 Option 保留在原位，创建一个带有对原始 Option 的引用的新 Option，并通过 Deref 强制执行其内容。

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

Run

impl<T: DerefMut> Option<T>

[src]

pub fn as_deref_mut(&mut self) -> Option<&mut T::Target>

1.40.0 [src]

从 Option<T> (或 &mut Option<T>) 转换为 Option<&mut T::Target>。

将原始 Option 保留在原位，创建一个新的 Option，其中包含对内部类型的 Deref::Target 类型的引用。

Examples

let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
    x.make_ascii_uppercase();
    x
}), Some("HEY".to_owned().as_mut_str()));

Run

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

[src]

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

1.33.0 [src]

将 Result 的 Option 转换为 Option 的 Result。

None 将被映射到 Ok(None)。 Some(Ok(_)) Some(Err(_)) 将被映射到 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, y.transpose());

Run

impl<T> Option<Option<T>>

[src]

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

1.40.0 [src]

从 Option<Option<T>> 转换为 Option<T>

Examples

基本用法:

let x: Option<Option<u32>> = Some(Some(6));
assert_eq!(Some(6), x.flatten());

let x: Option<Option<u32>> = Some(None);
assert_eq!(None, x.flatten());

let x: Option<Option<u32>> = None;
assert_eq!(None, x.flatten());

Run

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

let x: Option<Option<Option<u32>>> = Some(Some(Some(6)));
assert_eq!(Some(Some(6)), x.flatten());
assert_eq!(Some(6), x.flatten().flatten());

Run

Trait Implementations

impl<T: Clone> Clone for Option<T>

[src]

fn clone(&self) -> Self

[src]

返回值的副本。 Read more

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

[src]

从 source 执行复制分配。 Read more

impl<T: Debug> Debug for Option<T>

[src]

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

[src]

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

impl<T> Default for Option<T>

[src]

fn default() -> Option<T>

[src]

返回 None。

Examples

let opt: Option<u32> = Option::default();
assert!(opt.is_none());

Run

impl<'a, T> From<&'a Option<T>> for Option<&'a T>

1.30.0[src]

fn from(o: &'a Option<T>) -> Option<&'a T>

[src]

从 &Option<T> 转换为 Option<&T>。

Examples

将 Option<String> 转换为 Option<usize>，并保留原始格式。 map 方法按值取 self 参数，消耗原始值，因此该技术使用 from 首先取 Option 到原始值内部值的引用。

let s: Option<String> = Some(String::from("Hello, Rustaceans!"));
let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len());

println!("Can still print s: {:?}", s);

assert_eq!(o, Some(18));

Run

impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>

1.30.0[src]

fn from(o: &'a mut Option<T>) -> Option<&'a mut T>

[src]

从 &mut Option<T> 转换为 Option<&mut T>

Examples

let mut s = Some(String::from("Hello"));
let o: Option<&mut String> = Option::from(&mut s);

match o {
    Some(t) => *t = String::from("Hello, Rustaceans!"),
    None => (),
}

assert_eq!(s, Some(String::from("Hello, Rustaceans!")));

Run

impl<T> From<T> for Option<T>

1.12.0[src]

fn from(val: T) -> Option<T>

[src]

将 val 复制到新的 Some 中。

Examples

let o: Option<u8> = Option::from(67);

assert_eq!(Some(67), o);

Run

impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>

[src]

fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>

[src]

接受 Iterator 中的每个元素: 如果为 None，则不再获取其他元素，并返回 None。如果没有发生 None，则返回包含每个 Option 值的容器。

Examples

这是一个使 vector 中的每个整数递增的示例。当计算将导致溢出时，我们使用 add 的检查成员返回 None。

let items = vec![0_u16, 1, 2];

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| x.checked_add(1))
    .collect();

assert_eq!(res, Some(vec![1, 2, 3]));

Run

如您所见，这将返回预期的有效项。

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

let items = vec![2_u16, 1, 0];

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| x.checked_sub(1))
    .collect();

assert_eq!(res, None);

Run

由于最后一个元素为零，因此会下溢。因此，结果值为 None。

这是前一个示例的变体，显示在第一个 None 之后不再从 iter 提取其他元素。

let items = vec![3_u16, 2, 1, 10];

let mut shared = 0;

let res: Option<Vec<u16>> = items
    .iter()
    .map(|x| { shared += x; x.checked_sub(2) })
    .collect();

assert_eq!(res, None);
assert_eq!(shared, 6);

Run

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

impl<T> FromResidual<<Option<T> as Try>::Residual> for Option<T>

[src]

fn from_residual(residual: Option<Infallible>) -> Self

[src]

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

从兼容的 Residual 类型构造类型。 Read more

impl<T: Hash> Hash for Option<T>

[src]

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

[src]

将该值输入给定的 Hasher。 Read more

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

1.3.0 [src]

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

impl<T> IntoIterator for Option<T>

[src]

fn into_iter(self) -> IntoIter<T>ⓘ
Notable traits for IntoIter<A>
`impl<A> Iterator for IntoIter<A> type Item = A;`

[src]

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

Examples

let x = Some("string");
let v: Vec<&str> = x.into_iter().collect();
assert_eq!(v, ["string"]);

let x = None;
let v: Vec<&str> = x.into_iter().collect();
assert!(v.is_empty());

Run

type Item = T

被迭代的元素的类型。

type IntoIter = IntoIter<T>

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

impl<'a, T> IntoIterator for &'a Option<T>

1.4.0[src]

type Item = &'a T

被迭代的元素的类型。

type IntoIter = Iter<'a, T>

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

fn into_iter(self) -> Iter<'a, T>ⓘ
Notable traits for Iter<'a, A>
`impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;`

[src]

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

impl<'a, T> IntoIterator for &'a mut Option<T>

1.4.0[src]

type Item = &'a mut T

被迭代的元素的类型。

type IntoIter = IterMut<'a, T>

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

fn into_iter(self) -> IterMut<'a, T>ⓘ
Notable traits for IterMut<'a, A>
`impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;`

[src]

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

impl<T: Ord> Ord for Option<T>

[src]

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

[src]

此方法返回 self 和 other 之间的 Ordering。 Read more

#[must_use]
fn max(self, other: Self) -> Self where
Self: Sized,

1.21.0 [src]

比较并返回两个值中的最大值。 Read more

#[must_use]
fn min(self, other: Self) -> Self where
Self: Sized,

1.21.0 [src]

比较并返回两个值中的最小值。 Read more

#[must_use]
fn clamp(self, min: Self, max: Self) -> Self where
Self: Sized,

1.50.0 [src]

将值限制为一定的时间间隔。 Read more

impl<T: PartialEq> PartialEq<Option<T>> for Option<T>

[src]

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

[src]

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

fn ne(&self, other: &Option<T>) -> bool

[src]

此方法测试 !=。

impl<T: PartialOrd> PartialOrd<Option<T>> for Option<T>

[src]

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

[src]

如果存在，则此方法返回 self 和 other 值之间的顺序。 Read more

#[must_use]
fn lt(&self, other: &Rhs) -> bool

[src]

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。 Read more

#[must_use]
fn le(&self, other: &Rhs) -> bool

[src]

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。 Read more

#[must_use]
fn gt(&self, other: &Rhs) -> bool

[src]

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。 Read more

#[must_use]
fn ge(&self, other: &Rhs) -> bool

[src]

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 Read more

impl<T, U> Product<Option> for Option<T> where
T: Product,

1.37.0[src]

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

[src]

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

impl<T, U> Sum<Option> for Option<T> where
T: Sum,

1.37.0[src]

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

[src]

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

Examples

这总结了字符 ‘a’ 在字符串 vector 中的位置，如果单词没有字符 ‘a’，则该操作返回 None:

let words = vec!["have", "a", "great", "day"];
let total: Option<usize> = words.iter().map(|w| w.find('a')).sum();
assert_eq!(total, Some(5));

Run

impl<T> Try for Option<T>

[src]

type Output = T

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

当不短路时，? 产生的值的类型。

type Residual = Option<Infallible>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

短路时作为 ? 的一部分传递给 FromResidual::from_residual 的值的类型。 Read more

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

[src]

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

从它的 Output 类型构造类型。 Read more

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

[src]

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

在 ? 来决定操作符是应该生成一个值 (因为它返回了 ControlFlow::Continue)，还是将一个值传播回调用者(因为它返回了 ControlFlow::Break)。 Read more

Auto Trait Implementations

impl<T> Send for Option<T> where
T: Send,

impl<T> Sync for Option<T> where
T: Sync,

impl<T> Unpin for Option<T> where
T: Unpin,

Blanket Implementations

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

[src]

pub fn type_id(&Self) -> TypeId

[src]

获取 self 的 TypeId。 Read more

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

[src]

pub fn borrow(&Self) -> &T

[src]

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

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

[src]

pub fn borrow_mut(&mut Self) -> &mut T

[src]

从拥有的值中借用。 Read more

impl<T> From<!> for T

[src]

pub fn from(!) -> T

[src]

执行转换。

impl<T> From<T> for T

[src]

pub fn from(T) -> T

[src]

执行转换。

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

[src]

pub fn into(Self) -> U

[src]

执行转换。

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

[src]

type Error = Infallible

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

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

[src]

执行转换。

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

[src]

type Error = >::Error

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

pub fn try_into(Self) -> Result<U, >::Error>

[src]

执行转换。

Enum core::option::Option1.0.0[−][src]

Variants

Implementations

impl<T> Option<T>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]pub const fn is_some(&self) -> bool

#[must_use = "if you intended to assert that this doesn't have a value, consider \ `.and_then(|_| panic!(\"`Option` had a value when expected `None`\"))` instead"]pub const fn is_none(&self) -> bool

#[must_use]pub fn contains<U>(&self, x: &U) -> bool where U: PartialEq<T>,

pub const fn as_ref(&self) -> Option<&T>

pub fn as_mut(&mut self) -> Option<&mut T>

pub fn as_pin_ref(self: Pin<&Self>) -> Option<Pin<&T>>

pub fn as_pin_mut(self: Pin<&mut Self>) -> Option<Pin<&mut T>>

pub fn expect(self, msg: &str) -> T

pub fn unwrap(self) -> T

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

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

pub unsafe fn unwrap_unchecked(self) -> T

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U>

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

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

pub fn ok_or<E>(self, err: E) -> Result<T, E>

pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E>

pub fn iter(&self) -> Iter<'_, T>ⓘNotable traits for Iter<'a, A>impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;

pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘNotable traits for IterMut<'a, A>impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;

pub fn and<U>(self, optb: Option<U>) -> Option<U>

pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U>

pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Self

pub fn or(self, optb: Option<T>) -> Option<T>

pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T>

pub fn xor(self, optb: Option<T>) -> Option<T>

#[must_use = "if you intended to set a value, consider assignment instead"]pub fn insert(&mut self, value: T) -> &mut T

pub fn get_or_insert(&mut self, value: T) -> &mut T

pub fn get_or_insert_default(&mut self) -> &mut T where T: Default,

pub fn get_or_insert_with<F: FnOnce() -> T>(&mut self, f: F) -> &mut T

pub fn take(&mut self) -> Option<T>

pub fn replace(&mut self, value: T) -> Option<T>

pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)>

pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where F: FnOnce(T, U) -> R,

impl<T: Copy> Option<&T>

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

impl<T: Copy> Option<&mut T>

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

impl<T: Clone> Option<&T>

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

impl<T: Clone> Option<&mut T>

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

impl<T: Default> Option<T>

pub fn unwrap_or_default(self) -> T

impl<T: Deref> Option<T>

pub fn as_deref(&self) -> Option<&T::Target>

impl<T: DerefMut> Option<T>

pub fn as_deref_mut(&mut self) -> Option<&mut T::Target>

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

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

impl<T> Option<Option<T>>

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

Trait Implementations

impl<T: Clone> Clone for Option<T>

fn clone(&self) -> Self

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

impl<T: Debug> Debug for Option<T>

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

impl<T> Default for Option<T>

fn default() -> Option<T>

impl<'a, T> From<&'a Option<T>> for Option<&'a T>

fn from(o: &'a Option<T>) -> Option<&'a T>

impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>

fn from(o: &'a mut Option<T>) -> Option<&'a mut T>

impl<T> From<T> for Option<T>

fn from(val: T) -> Option<T>

impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V>

fn from_iter<I: IntoIterator<Item = Option<A>>>(iter: I) -> Option<V>

impl<T> FromResidual<<Option<T> as Try>::Residual> for Option<T>

fn from_residual(residual: Option<Infallible>) -> Self

impl<T: Hash> Hash for Option<T>

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

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

impl<T> IntoIterator for Option<T>

fn into_iter(self) -> IntoIter<T>ⓘNotable traits for IntoIter<A>impl<A> Iterator for IntoIter<A> type Item = A;

type Item = T

type IntoIter = IntoIter<T>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]
pub const fn is_some(&self) -> bool

#[must_use = "if you intended to assert that this doesn't have a value, consider \ `.and_then(|_| panic!(\"`Option` had a value when expected `None`\"))` instead"]
pub const fn is_none(&self) -> bool

#[must_use]
pub fn contains<U>(&self, x: &U) -> bool where
U: PartialEq<T>,

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

pub fn iter(&self) -> Iter<'_, T>ⓘ
Notable traits for Iter<'a, A>
`impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;`

pub fn iter_mut(&mut self) -> IterMut<'_, T>ⓘ
Notable traits for IterMut<'a, A>
`impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;`

#[must_use = "if you intended to set a value, consider assignment instead"]
pub fn insert(&mut self, value: T) -> &mut T

pub fn get_or_insert_default(&mut self) -> &mut T where
T: Default,

pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where
F: FnOnce(T, U) -> R,

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

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

fn into_iter(self) -> IntoIter<T>ⓘ
Notable traits for IntoIter<A>
`impl<A> Iterator for IntoIter<A> type Item = A;`

fn into_iter(self) -> Iter<'a, T>ⓘ
Notable traits for Iter<'a, A>
`impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;`

fn into_iter(self) -> IterMut<'a, T>ⓘ
Notable traits for IterMut<'a, A>
`impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;`

#[must_use]
fn max(self, other: Self) -> Self where
Self: Sized,

#[must_use]
fn min(self, other: Self) -> Self where
Self: Sized,

#[must_use]
fn clamp(self, min: Self, max: Self) -> Self where
Self: Sized,