diff options
| -rw-r--r-- | library/core/src/option.rs | 158 | ||||
| -rw-r--r-- | library/core/src/result.rs | 126 |
2 files changed, 160 insertions, 124 deletions
diff --git a/library/core/src/option.rs b/library/core/src/option.rs index 8c12bcff5cc..bd9ac7bb3d9 100644 --- a/library/core/src/option.rs +++ b/library/core/src/option.rs @@ -49,6 +49,8 @@ //! no "null" references. Instead, Rust has *optional* pointers, like //! the optional owned box, [`Option`]`<`[`Box<T>`]`>`. //! +//! [`Box<T>`]: ../../std/boxed/struct.Box.html +//! //! The following example uses [`Option`] to create an optional box of //! [`i32`]. Notice that in order to use the inner [`i32`] value, the //! `check_optional` function first needs to use pattern matching to @@ -83,6 +85,10 @@ //! * [`ptr::NonNull<U>`] //! * `#[repr(transparent)]` struct around one of the types in this list. //! +//! [`Box<U>`]: ../../std/boxed/struct.Box.html +//! [`num::NonZero*`]: crate::num +//! [`ptr::NonNull<U>`]: crate::ptr::NonNull +//! //! This is called the "null pointer optimization" or NPO. //! //! It is further guaranteed that, for the cases above, one can @@ -100,32 +106,32 @@ //! The [`is_some`] and [`is_none`] methods return [`true`] if the [`Option`] //! is [`Some`] or [`None`], respectively. //! -//! [`is_some`]: Option::is_some //! [`is_none`]: Option::is_none +//! [`is_some`]: Option::is_some //! //! ## Adapters for working with references //! //! * [`as_ref`] converts from `&Option<T>` to `Option<&T>` //! * [`as_mut`] converts from `&mut Option<T>` to `Option<&mut T>` //! * [`as_deref`] converts from `&Option<T>` to `Option<&T::Target>` -//! * [`as_deref_mut`] converts from `&mut Option<T>` to `Option<&mut T::Target>` -//! * [`as_pin_ref`] converts from [`&Pin`]`<Option<T>>` to `Option<`[`Pin`]`<&T>>` -//! * [`as_pin_mut`] converts from [`&mut Pin`]`<Option<T>>` to `Option<`[`Pin`]`<&mut T>>` +//! * [`as_deref_mut`] converts from `&mut Option<T>` to +//! `Option<&mut T::Target>` +//! * [`as_pin_ref`] converts from [`Pin`]`<&Option<T>>` to +//! `Option<`[`Pin`]`<&T>>` +//! * [`as_pin_mut`] converts from [`Pin`]`<&mut Option<T>>` to +//! `Option<`[`Pin`]`<&mut T>>` //! -//! [`&mut Pin`]: crate::pin::Pin -//! [`&Pin`]: crate::pin::Pin //! [`as_deref`]: Option::as_deref //! [`as_deref_mut`]: Option::as_deref_mut //! [`as_mut`]: Option::as_mut -//! [`as_pin_ref`]: Option::as_pin_ref //! [`as_pin_mut`]: Option::as_pin_mut +//! [`as_pin_ref`]: Option::as_pin_ref //! [`as_ref`]: Option::as_ref -//! [`Pin`]: crate::pin::Pin //! //! ## Extracting the contained value //! -//! These methods extract the contained value in an [`Option`] when it is -//! the [`Some`] variant. If the [`Option`] is [`None`]: +//! These methods extract the contained value in an [`Option<T>`] when it +//! is the [`Some`] variant. If the [`Option`] is [`None`]: //! //! * [`expect`] panics with a provided custom message //! * [`unwrap`] panics with a generic message @@ -135,7 +141,6 @@ //! * [`unwrap_or_else`] returns the result of evaluating the provided //! function //! -//! [`Default`]: crate::default::Default //! [`expect`]: Option::expect //! [`unwrap`]: Option::unwrap //! [`unwrap_or`]: Option::unwrap_or @@ -144,7 +149,7 @@ //! //! ## Transforming contained values //! -//! These transformations are from [`Option`] to [`Result`]. +//! These methods transform [`Option`] to [`Result`]: //! //! * [`ok_or`] transforms [`Some(v)`] to [`Ok(v)`], and [`None`] to //! [`Err(err)`] using the provided default `err` value @@ -153,7 +158,14 @@ //! * [`transpose`] transposes an [`Option`] of a [`Result`] into a //! [`Result`] of an [`Option`] //! -//! These transformations are on [`Some`] values. +//! [`Err(err)`]: Err +//! [`Ok(v)`]: Ok +//! [`Some(v)`]: Some +//! [`ok_or`]: Option::ok_or +//! [`ok_or_else`]: Option::ok_or_else +//! [`transpose`]: Option::transpose +//! +//! These methods transform the [`Some`] variant: //! //! * [`filter`] calls the provided predicate function on the contained //! value `t` if the [`Option`] is [`Some(t)`], and returns [`Some(t)`] @@ -163,15 +175,26 @@ //! * [`map`] transforms [`Option<T>`] to [`Option<U>`] by applying the //! provided function to the contained value of [`Some`] and leaving //! [`None`] values unchanged -//! * [`map_or`] transforms [`Option<T>`] to a value of `U` by applying the -//! provided function to the contained value of [`Some`], or transforms -//! [`None`] to a provided default value of `U` -//! * [`map_or_else`] transforms [`Option<T>`] to a value of `U` by -//! applying the provided function to the contained value of [`Some`], or -//! transforms [`None`] to a value of `U` using a provided fallback -//! function //! -//! These transformations combine two [`Some`] values. +//! [`Some(t)`]: Some +//! [`filter`]: Option::filter +//! [`flatten`]: Option::flatten +//! [`map`]: Option::map +//! +//! These methods transform [`Option<T>`] to a value of a possibly +//! different type `U`: +//! +//! * [`map_or`] applies the provided function to the contained value of +//! [`Some`], or returns the provided default value if the [`Option`] is +//! [`None`] +//! * [`map_or_else`] applies the provided function to the contained value +//! of [`Some`], or returns the result of evaluating the provided +//! fallback function if the [`Option`] is [`None`] +//! +//! [`map_or`]: Option::map_or +//! [`map_or_else`]: Option::map_or_else +//! +//! These methods combine the [`Some`] variants of two [`Option`] values: //! //! * [`zip`] returns [`Some((s, o))`] if `self` is [`Some(s)`] and the //! provided [`Option`] value is [`Some(o)`]; otherwise, returns [`None`] @@ -179,22 +202,10 @@ //! [`Some(f(s, o))`] if `self` is [`Some(s)`] and the provided //! [`Option`] value is [`Some(o)`]; otherwise, returns [`None`] //! -//! [`Err(err)`]: Err -//! [`filter`]: Option::filter -//! [`flatten`]: Option::flatten -//! [`map`]: Option::map -//! [`map_or`]: Option::map_or -//! [`map_or_else`]: Option::map_or_else -//! [`Ok(v)`]: Ok -//! [`ok_or`]: Option::ok_or -//! [`ok_or_else`]: Option::ok_or_else //! [`Some(f(s, o))`]: Some //! [`Some(o)`]: Some //! [`Some(s)`]: Some //! [`Some((s, o))`]: Some -//! [`Some(t)`]: Some -//! [`Some(v)`]: Some -//! [`transpose`]: Option::transpose //! [`zip`]: Option::zip //! [`zip_with`]: Option::zip_with //! @@ -223,6 +234,10 @@ //! | [`xor`] | `Some(x)` | `None` | `Some(x)` | //! | [`xor`] | `Some(x)` | `Some(y)` | `None` | //! +//! [`and`]: Option::and +//! [`or`]: Option::or +//! [`xor`]: Option::xor +//! //! The [`and_then`] and [`or_else`] methods take a function as input, and //! only evaluate the function when they need to produce a new value. Only //! the [`and_then`] method can produce an [`Option<U>`] value having a @@ -237,11 +252,8 @@ //! | [`or_else`] | `None` | (not provided) | `Some(y)` | `Some(y)` | //! | [`or_else`] | `Some(x)` | (not provided) | (not evaluated) | `Some(x)` | //! -//! [`and`]: Option::and //! [`and_then`]: Option::and_then -//! [`or`]: Option::or //! [`or_else`]: Option::or_else -//! [`xor`]: Option::xor //! //! This is an example of using methods like [`and_then`] and [`or`] in a //! pipeline of method calls. Early stages of the pipeline pass failure @@ -282,7 +294,11 @@ //! [`once(v)`] if the [`Option`] is [`Some(v)`], and like [`empty()`] if //! the [`Option`] is [`None`]. //! -//! Iterators over [`Option`] come in three types: +//! [`Some(v)`]: Some +//! [`empty()`]: crate::iter::empty +//! [`once(v)`]: crate::iter::once +//! +//! Iterators over [`Option<T>`] come in three types: //! //! * [`into_iter`] consumes the [`Option`] and produces the contained //! value @@ -291,12 +307,9 @@ //! * [`iter_mut`] produces a mutable reference of type `&mut T` to the //! contained value //! -//! [`empty()`]: crate::iter::empty //! [`into_iter`]: Option::into_iter //! [`iter`]: Option::iter //! [`iter_mut`]: Option::iter_mut -//! [`once(v)`]: crate::iter::once -//! [`Some(v)`]: Some //! //! An iterator over [`Option`] can be useful when chaining iterators, for //! example, to conditionally insert items. (It's not always necessary to @@ -334,6 +347,9 @@ //! we can't return `impl Iterator` anymore because the concrete types of //! the return values differ. //! +//! [`empty()`]: crate::iter::empty +//! [`once()`]: crate::iter::once +//! //! ```compile_fail,E0308 //! # use std::iter::{empty, once}; //! // This won't compile because all possible returns from the function @@ -347,16 +363,14 @@ //! } //! ``` //! -//! [`once()`]: crate::iter::once -//! //! ## Collecting into `Option` //! -//! [`Option`] implements the [`FromIterator`] trait, which allows an -//! iterator over [`Option`] values to be collected into an [`Option`] of a -//! collection of each contained value of the original [`Option`] values, -//! or [`None`] if any of the elements was [`None`]. +//! [`Option`] implements the [`FromIterator`][impl-FromIterator] trait, +//! which allows an iterator over [`Option`] values to be collected into an +//! [`Option`] of a collection of each contained value of the original +//! [`Option`] values, or [`None`] if any of the elements was [`None`]. //! -//! [`FromIterator`]: Option#impl-FromIterator%3COption%3CA%3E%3E +//! [impl-FromIterator]: Option#impl-FromIterator%3COption%3CA%3E%3E //! //! ``` //! let v = vec![Some(2), Some(4), None, Some(8)]; @@ -367,43 +381,52 @@ //! assert_eq!(res, Some(vec![2, 4, 8])); //! ``` //! -//! [`Option`] also implements the [`Product`] and [`Sum`] traits, allowing -//! an iterator over [`Option`] values to provide the -//! [`product`][m.product] and [`sum`][m.sum] methods. +//! [`Option`] also implements the [`Product`][impl-Product] and +//! [`Sum`][impl-Sum] traits, allowing an iterator over [`Option`] values +//! to provide the [`product`][Iterator::product] and +//! [`sum`][Iterator::sum] methods. //! -//! [`Product`]: Option#impl-Product%3COption%3CU%3E%3E -//! [`Sum`]: Option#impl-Sum%3COption%3CU%3E%3E -//! [m.product]: crate::iter::Iterator::product -//! [m.sum]: crate::iter::Iterator::sum +//! [impl-Product]: Option#impl-Product%3COption%3CU%3E%3E +//! [impl-Sum]: Option#impl-Sum%3COption%3CU%3E%3E +//! +//! ``` +//! let v = vec![None, Some(1), Some(2), Some(3)]; +//! let res: Option<i32> = v.into_iter().sum(); +//! assert_eq!(res, None); +//! let v = vec![Some(1), Some(2), Some(21)]; +//! let res: Option<i32> = v.into_iter().product(); +//! assert_eq!(res, Some(42)); +//! ``` //! //! ## Modifying an [`Option`] in-place //! -//! These methods return a mutable reference to the contained value of a -//! [`Some`]. +//! These methods return a mutable reference to the contained value of an +//! [`Option<T>`]: //! //! * [`insert`] inserts a value, dropping any old contents //! * [`get_or_insert`] gets the current value, inserting a provided //! default value if it is [`None`] //! * [`get_or_insert_default`] gets the current value, inserting the -//! default value of type `T` if it is [`None`] +//! default value of type `T` (which must implement [`Default`]) if it is +//! [`None`] //! * [`get_or_insert_with`] gets the current value, inserting a default //! computed by the provided function if it is [`None`] //! -//! [`insert`]: Option::insert //! [`get_or_insert`]: Option::get_or_insert //! [`get_or_insert_default`]: Option::get_or_insert_default //! [`get_or_insert_with`]: Option::get_or_insert_with +//! [`insert`]: Option::insert //! -//! These methods transfer ownership of the [`Option`]. +//! These methods transfer ownership of the contained of an [`Option`]: //! -//! * [`take`] takes ownership of the [`Option`], including any contained -//! value, replacing it with [`None`] -//! * [`replace`] takes ownership of the [`Option`], including any -//! contained value, replacing it with a [`Some`] containing the provided -//! value +//! * [`take`] takes ownership of the contained value of an [`Option`], if +//! any, replacing the [`Option`] with [`None`] +//! * [`replace`] takes ownership of the contained value of an [`Option`], +//! if any, replacing the [`Option`] with a [`Some`] containing the +//! provided value //! -//! [`take`]: Option::take //! [`replace`]: Option::replace +//! [`take`]: Option::take //! //! # Examples //! @@ -456,11 +479,6 @@ //! None => println!("there are no animals :("), //! } //! ``` -//! -//! [`Box<T>`]: ../../std/boxed/struct.Box.html -//! [`Box<U>`]: ../../std/boxed/struct.Box.html -//! [`num::NonZero*`]: crate::num -//! [`ptr::NonNull<U>`]: crate::ptr::NonNull #![stable(feature = "rust1", since = "1.0.0")] diff --git a/library/core/src/result.rs b/library/core/src/result.rs index 75ba70dea1f..b9bb8cc9406 100644 --- a/library/core/src/result.rs +++ b/library/core/src/result.rs @@ -242,8 +242,9 @@ //! //! * [`as_ref`] converts from `&Result<T, E>` to `Result<&T, &E>` //! * [`as_mut`] converts from `&mut Result<T, E>` to `Result<&mut T, &mut E>` -//! * [`as_deref`] converts from `&Result<T>` to `Result<&T::Target, &E>` -//! * [`as_deref_mut`] converts from `&mut Result<T>` to `Result<&mut T::Target, &mut E>` +//! * [`as_deref`] converts from `&Result<T, E>` to `Result<&T::Target, &E>` +//! * [`as_deref_mut`] converts from `&mut Result<T, E>` to +//! `Result<&mut T::Target, &mut E>` //! //! [`as_deref`]: Result::as_deref //! [`as_deref_mut`]: Result::as_deref_mut @@ -252,8 +253,8 @@ //! //! ## Extracting contained values //! -//! These methods extract the contained value in a [`Result`] when it is -//! the [`Ok`] variant. If the [`Result`] is [`Err`]: +//! These methods extract the contained value in a [`Result<T, E>`] when it +//! is the [`Ok`] variant. If the [`Result`] is [`Err`]: //! //! * [`expect`] panics with a provided custom message //! * [`unwrap`] panics with a generic message @@ -266,26 +267,27 @@ //! The panicking methods [`expect`] and [`unwrap`] require `E` to //! implement the [`Debug`] trait. //! -//! These methods extract the contained value in a [`Result`] when it is -//! the [`Err`] variant. They require `T` to implement the [`Debug`] trait. -//! If the [`Result`] is [`Ok`]: +//! [`Debug`]: crate::fmt::Debug +//! [`expect`]: Result::expect +//! [`unwrap`]: Result::unwrap +//! [`unwrap_or`]: Result::unwrap_or +//! [`unwrap_or_default`]: Result::unwrap_or_default +//! [`unwrap_or_else`]: Result::unwrap_or_else +//! +//! These methods extract the contained value in a [`Result<T, E>`] when it +//! is the [`Err`] variant. They require `T` to implement the [`Debug`] +//! trait. If the [`Result`] is [`Ok`]: //! //! * [`expect_err`] panics with a provided custom message //! * [`unwrap_err`] panics with a generic message //! //! [`Debug`]: crate::fmt::Debug -//! [`Default`]: crate::default::Default -//! [`expect`]: Result::expect //! [`expect_err`]: Result::expect_err -//! [`unwrap`]: Result::unwrap //! [`unwrap_err`]: Result::unwrap_err -//! [`unwrap_or`]: Result::unwrap_or -//! [`unwrap_or_default`]: Result::unwrap_or_default -//! [`unwrap_or_else`]: Result::unwrap_or_else //! //! ## Transforming contained values //! -//! These transformations are from [`Result`] to [`Option`]: +//! These methods transform [`Result`] to [`Option`]: //! //! * [`err`][Result::err] transforms [`Result<T, E>`] into [`Option<E>`], //! mapping [`Err(e)`] to [`Some(e)`] and [`Ok(v)`] to [`None`] @@ -294,35 +296,44 @@ //! * [`transpose`] transposes a [`Result`] of an [`Option`] into an //! [`Option`] of a [`Result`] //! -//! These transformations are on [`Ok`] values: +// Do NOT add link reference definitions for `err` or `ok`, because they +// will generate numerous incorrect URLs for `Err` and `Ok` elsewhere, due +// to case folding. +//! +//! [`Err(e)`]: Err +//! [`Ok(v)`]: Ok +//! [`Some(e)`]: Option::Some +//! [`Some(v)`]: Option::Some +//! [`transpose`]: Result::transpose +//! +//! This method transforms the contained value of the [`Ok`] variant: //! //! * [`map`] transforms [`Result<T, E>`] into [`Result<U, E>`] by applying //! the provided function to the contained value of [`Ok`] and leaving //! [`Err`] values unchanged -//! * [`map_or`] transforms [`Result<T, E>`] into a value of `U` by -//! applying the provided function to the contained value of [`Ok`], or -//! returns the provided default value of `U` if the [`Result`] is -//! [`Err`] -//! * [`map_or_else`] transforms [`Result<T, E>`] into a value of `U` by -//! applying the provided function to the contained value of [`Ok`], or -//! applies the provided fallback function to the contained value of -//! [`Err`] //! -//! This transformation is on [`Err`] values: +//! [`map`]: Result::map +//! +//! This method transforms the contained value of the [`Err`] variant: //! //! * [`map_err`] transforms [`Result<T, E>`] into [`Result<T, F>`] by //! applying the provided function to the contained value of [`Err`] and //! leaving [`Ok`] values unchanged //! -//! [`Err(e)`]: Err -//! [`Ok(v)`]: Ok -//! [`Some(e)`]: Option::Some -//! [`Some(v)`]: Option::Some -//! [`map`]: Result::map //! [`map_err`]: Result::map_err +//! +//! These methods transform a [`Result<T, E>`] into a value of a possibly +//! different type `U`: +//! +//! * [`map_or`] applies the provided function to the contained value of +//! [`Ok`], or returns the provided default value if the [`Result`] is +//! [`Err`] +//! * [`map_or_else`] applies the provided function to the contained value +//! of [`Ok`], or applies the provided fallback function to the contained +//! value of [`Err`] +//! //! [`map_or`]: Result::map_or //! [`map_or_else`]: Result::map_or_else -//! [`transpose`]: Result::transpose //! //! ## Boolean operators //! @@ -346,6 +357,9 @@ //! | [`or`] | `Err(e)` | `Ok(y)` | `Ok(y)` | //! | [`or`] | `Ok(x)` | (ignored) | `Ok(x)` | //! +//! [`and`]: Result::and +//! [`or`]: Result::or +//! //! The [`and_then`] and [`or_else`] methods take a function as input, and //! only evaluate the function when they need to produce a new value. The //! [`and_then`] method can produce a [`Result<U, E>`] value having a @@ -362,9 +376,7 @@ //! | [`or_else`] | `Err(e)` | `e` | `Ok(y)` | `Ok(y)` | //! | [`or_else`] | `Ok(x)` | (not provided) | (not evaluated) | `Ok(x)` | //! -//! [`and`]: Result::and //! [`and_then`]: Result::and_then -//! [`or`]: Result::or //! [`or_else`]: Result::or_else //! //! ## Iterating over `Result` @@ -373,10 +385,14 @@ //! iterator that is conditionally empty. The iterator will either produce //! a single value (when the [`Result`] is [`Ok`]), or produce no values //! (when the [`Result`] is [`Err`]). For example, [`into_iter`] acts like -//! [`once(v)`] if the [`Result`] is [`Ok(v)`], and like [`empty()`] if -//! the [`Result`] is [`Err(err)`]. +//! [`once(v)`] if the [`Result`] is [`Ok(v)`], and like [`empty()`] if the +//! [`Result`] is [`Err`]. +//! +//! [`Ok(v)`]: Ok +//! [`empty()`]: crate::iter::empty +//! [`once(v)`]: crate::iter::once //! -//! Iterators over [`Result`] come in three types: +//! Iterators over [`Result<T, E>`] come in three types: //! //! * [`into_iter`] consumes the [`Result`] and produces the contained //! value @@ -387,22 +403,16 @@ //! //! See [Iterating over `Option`] for examples of how this can be useful. //! -//! [`Err(err)`]: Err //! [Iterating over `Option`]: crate::option#iterating-over-option -//! [`Ok(v)`]: Ok -//! [`empty()`]: crate::iter::empty //! [`into_iter`]: Result::into_iter //! [`iter`]: Result::iter //! [`iter_mut`]: Result::iter_mut -//! [`once(v)`]: crate::iter::once //! //! You might want to use an iterator chain to do multiple instances of an //! operation that can fail, but would like to ignore failures while //! continuing to process the successful results. In this example, we take //! advantage of the iterable nature of [`Result`] to select only the -//! [`Ok`] values using [`flatten`]. -//! -//! [`flatten`]: crate::iter::Iterator::flatten +//! [`Ok`] values using [`flatten`][Iterator::flatten]. //! //! ``` //! # use std::str::FromStr; @@ -426,12 +436,12 @@ //! //! ## Collecting into `Result` //! -//! [`Result`] implements the [`FromIterator`] trait, which allows an -//! iterator over [`Result`] values to be collected into a [`Result`] of a -//! collection of each contained value of the original [`Result`] values, -//! or [`Err`] if any of the elements was [`Err`]. +//! [`Result`] implements the [`FromIterator`][impl-FromIterator] trait, +//! which allows an iterator over [`Result`] values to be collected into a +//! [`Result`] of a collection of each contained value of the original +//! [`Result`] values, or [`Err`] if any of the elements was [`Err`]. //! -//! [`FromIterator`]: Result#impl-FromIterator%3CResult%3CA%2C%20E%3E%3E +//! [impl-FromIterator]: Result#impl-FromIterator%3CResult%3CA%2C%20E%3E%3E //! //! ``` //! let v = vec![Ok(2), Ok(4), Err("err!"), Ok(8)]; @@ -442,14 +452,22 @@ //! assert_eq!(res, Ok(vec![2, 4, 8])); //! ``` //! -//! [`Result`] also implements the [`Product`] and [`Sum`] traits, allowing -//! an iterator over [`Result`] values to provide the -//! [`product`][m.product] and [`sum`][m.sum] methods. +//! [`Result`] also implements the [`Product`][impl-Product] and +//! [`Sum`][impl-Sum] traits, allowing an iterator over [`Result`] values +//! to provide the [`product`][Iterator::product] and +//! [`sum`][Iterator::sum] methods. //! -//! [`Product`]: Result#impl-Product%3CResult%3CU%2C%20E%3E%3E -//! [`Sum`]: Result#impl-Sum%3CResult%3CU%2C%20E%3E%3E -//! [m.product]: crate::iter::Iterator::product -//! [m.sum]: crate::iter::Iterator::sum +//! [impl-Product]: Result#impl-Product%3CResult%3CU%2C%20E%3E%3E +//! [impl-Sum]: Result#impl-Sum%3CResult%3CU%2C%20E%3E%3E +//! +//! ``` +//! let v = vec![Err("error!"), Ok(1), Ok(2), Ok(3), Err("foo")]; +//! let res: Result<i32, &str> = v.into_iter().sum(); +//! assert_eq!(res, Err("error!")); +//! let v: Vec<Result<i32, &str>> = vec![Ok(1), Ok(2), Ok(21)]; +//! let res: Result<i32, &str> = v.into_iter().product(); +//! assert_eq!(res, Ok(42)); +//! ``` #![stable(feature = "rust1", since = "1.0.0")] |