diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index e6312b8b2d947..0022df4f65ff7 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -810,6 +810,45 @@ impl<T> Option<T> {
}
}
+ /// Returns the contained [`Some`] value or a default.
+ ///
+ /// Consumes the `self` argument then, if [`Some`], returns the contained
+ /// value, otherwise if [`None`], returns the [default value] for that
+ /// type.
+ ///
+ /// # Examples
+ ///
+ /// Converts a string to an integer, turning poorly-formed strings
+ /// into 0 (the default value for integers). [`parse`] converts
+ /// a string to any other type that implements [`FromStr`], returning
+ /// [`None`] on error.
+ ///
+ /// ```
+ /// 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);
+ /// ```
+ ///
+ /// [default value]: Default::default
+ /// [`parse`]: str::parse
+ /// [`FromStr`]: crate::str::FromStr
+ #[inline]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
+ pub const fn unwrap_or_default(self) -> T
+ where
+ T: ~const Default,
+ {
+ match self {
+ Some(x) => x,
+ None => Default::default(),
+ }
+ }
+
/// Returns the contained [`Some`] value, consuming the `self` value,
/// without checking that the value is not [`None`].
///
@@ -1033,6 +1072,58 @@ impl<T> Option<T> {
}
}
+ /// Converts from `Option<T>` (or `&Option<T>`) to `Option<&T::Target>`.
+ ///
+ /// Leaves the original Option in-place, creating a new one with a reference
+ /// to the original one, additionally coercing the contents via [`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);
+ /// ```
+ #[stable(feature = "option_deref", since = "1.40.0")]
+ #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
+ pub const fn as_deref(&self) -> Option<&T::Target>
+ where
+ T: ~const Deref,
+ {
+ match self.as_ref() {
+ Some(t) => Some(t.deref()),
+ None => None,
+ }
+ }
+
+ /// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`.
+ ///
+ /// Leaves the original `Option` in-place, creating a new one containing a mutable reference to
+ /// the inner type's [`Deref::Target`] type.
+ ///
+ /// # 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()));
+ /// ```
+ #[stable(feature = "option_deref", since = "1.40.0")]
+ #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
+ pub const fn as_deref_mut(&mut self) -> Option<&mut T::Target>
+ where
+ T: ~const DerefMut,
+ {
+ match self.as_mut() {
+ Some(t) => Some(t.deref_mut()),
+ None => None,
+ }
+ }
+
/////////////////////////////////////////////////////////////////////////
// Iterator constructors
/////////////////////////////////////////////////////////////////////////
@@ -1581,7 +1672,7 @@ impl<T, U> Option<(T, U)> {
}
}
-impl<T: Copy> Option<&T> {
+impl<T> Option<&T> {
/// Maps an `Option<&T>` to an `Option<T>` by copying the contents of the
/// option.
///
@@ -1597,7 +1688,10 @@ impl<T: Copy> Option<&T> {
#[must_use = "`self` will be dropped if the result is not used"]
#[stable(feature = "copied", since = "1.35.0")]
#[rustc_const_unstable(feature = "const_option", issue = "67441")]
- pub const fn copied(self) -> Option<T> {
+ pub const fn copied(self) -> Option<T>
+ where
+ T: Copy,
+ {
// FIXME: this implementation, which sidesteps using `Option::map` since it's not const
// ready yet, should be reverted when possible to avoid code repetition
match self {
@@ -1605,33 +1699,7 @@ impl<T: Copy> Option<&T> {
None => None,
}
}
-}
-impl<T: Copy> Option<&mut T> {
- /// Maps an `Option<&mut T>` to an `Option<T>` by copying the contents of the
- /// option.
- ///
- /// # 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));
- /// ```
- #[must_use = "`self` will be dropped if the result is not used"]
- #[stable(feature = "copied", since = "1.35.0")]
- #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
- pub const fn copied(self) -> Option<T> {
- match self {
- Some(&mut t) => Some(t),
- None => None,
- }
- }
-}
-
-impl<T: Clone> Option<&T> {
/// Maps an `Option<&T>` to an `Option<T>` by cloning the contents of the
/// option.
///
@@ -1658,8 +1726,8 @@ impl<T: Clone> Option<&T> {
}
}
-impl<T: Clone> Option<&mut T> {
- /// Maps an `Option<&mut T>` to an `Option<T>` by cloning the contents of the
+impl<T> Option<&mut T> {
+ /// Maps an `Option<&mut T>` to an `Option<T>` by copying the contents of the
/// option.
///
/// # Examples
@@ -1668,115 +1736,43 @@ impl<T: Clone> Option<&mut T> {
/// 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));
+ /// let copied = opt_x.copied();
+ /// assert_eq!(copied, Some(12));
/// ```
#[must_use = "`self` will be dropped if the result is not used"]
- #[stable(since = "1.26.0", feature = "option_ref_mut_cloned")]
- #[rustc_const_unstable(feature = "const_option_cloned", issue = "91582")]
- pub const fn cloned(self) -> Option<T>
- where
- T: ~const Clone,
- {
- match self {
- Some(t) => Some(t.clone()),
- None => None,
- }
- }
-}
-
-impl<T: Default> Option<T> {
- /// Returns the contained [`Some`] value or a default.
- ///
- /// Consumes the `self` argument then, if [`Some`], returns the contained
- /// value, otherwise if [`None`], returns the [default value] for that
- /// type.
- ///
- /// # Examples
- ///
- /// Converts a string to an integer, turning poorly-formed strings
- /// into 0 (the default value for integers). [`parse`] converts
- /// a string to any other type that implements [`FromStr`], returning
- /// [`None`] on error.
- ///
- /// ```
- /// 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);
- /// ```
- ///
- /// [default value]: Default::default
- /// [`parse`]: str::parse
- /// [`FromStr`]: crate::str::FromStr
- #[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
+ #[stable(feature = "copied", since = "1.35.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
- pub const fn unwrap_or_default(self) -> T
+ pub const fn copied(self) -> Option<T>
where
- T: ~const Default,
+ T: Copy,
{
match self {
- Some(x) => x,
- None => Default::default(),
- }
- }
-}
-
-impl<T: Deref> Option<T> {
- /// Converts from `Option<T>` (or `&Option<T>`) to `Option<&T::Target>`.
- ///
- /// Leaves the original Option in-place, creating a new one with a reference
- /// to the original one, additionally coercing the contents via [`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);
- /// ```
- #[stable(feature = "option_deref", since = "1.40.0")]
- #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
- pub const fn as_deref(&self) -> Option<&T::Target>
- where
- T: ~const Deref,
- {
- match self.as_ref() {
- Some(t) => Some(t.deref()),
+ Some(&mut t) => Some(t),
None => None,
}
}
-}
-impl<T: DerefMut> Option<T> {
- /// Converts from `Option<T>` (or `&mut Option<T>`) to `Option<&mut T::Target>`.
- ///
- /// Leaves the original `Option` in-place, creating a new one containing a mutable reference to
- /// the inner type's [`Deref::Target`] type.
+ /// Maps an `Option<&mut T>` to an `Option<T>` by cloning the contents of the
+ /// option.
///
/// # 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()));
+ /// 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));
/// ```
- #[stable(feature = "option_deref", since = "1.40.0")]
- #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
- pub const fn as_deref_mut(&mut self) -> Option<&mut T::Target>
+ #[must_use = "`self` will be dropped if the result is not used"]
+ #[stable(since = "1.26.0", feature = "option_ref_mut_cloned")]
+ #[rustc_const_unstable(feature = "const_option_cloned", issue = "91582")]
+ pub const fn cloned(self) -> Option<T>
where
- T: ~const DerefMut,
+ T: ~const Clone,
{
- match self.as_mut() {
- Some(t) => Some(t.deref_mut()),
+ match self {
+ Some(t) => Some(t.clone()),
None => None,
}
}
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 3cde63493d322..f46632e7a8d20 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -901,6 +901,56 @@ impl<T, E> Result<T, E> {
self
}
+ /// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&<T as Deref>::Target, &E>`.
+ ///
+ /// Coerces the [`Ok`] variant of the original [`Result`] via [`Deref`](crate::ops::Deref)
+ /// and returns the new [`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);
+ /// ```
+ #[stable(feature = "inner_deref", since = "1.47.0")]
+ pub fn as_deref(&self) -> Result<&T::Target, &E>
+ where
+ T: Deref,
+ {
+ self.as_ref().map(|t| t.deref())
+ }
+
+ /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`.
+ ///
+ /// Coerces the [`Ok`] variant of the original [`Result`] via [`DerefMut`](crate::ops::DerefMut)
+ /// and returns the new [`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);
+ /// ```
+ #[stable(feature = "inner_deref", since = "1.47.0")]
+ pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E>
+ where
+ T: DerefMut,
+ {
+ self.as_mut().map(|t| t.deref_mut())
+ }
+
/////////////////////////////////////////////////////////////////////////
// Iterator constructors
/////////////////////////////////////////////////////////////////////////
@@ -951,608 +1001,583 @@ impl<T, E> Result<T, E> {
IterMut { inner: self.as_mut().ok() }
}
- ////////////////////////////////////////////////////////////////////////
- // Boolean operations on the values, eager and lazy
+ /////////////////////////////////////////////////////////////////////////
+ // Extract a value
/////////////////////////////////////////////////////////////////////////
- /// Returns `res` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.
- ///
+ /// Returns the contained [`Ok`] value, consuming the `self` value.
///
- /// # Examples
+ /// # Panics
///
- /// Basic usage:
+ /// Panics if the value is an [`Err`], with a panic message including the
+ /// passed message, and the content of the [`Err`].
///
- /// ```
- /// 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"));
+ /// # Examples
///
- /// 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"));
+ /// Basic usage:
///
- /// 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"));
+ /// ```should_panic
+ /// let x: Result<u32, &str> = Err("emergency failure");
+ /// x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
/// ```
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn and<U>(self, res: Result<U, E>) -> Result<U, E> {
+ #[track_caller]
+ #[stable(feature = "result_expect", since = "1.4.0")]
+ pub fn expect(self, msg: &str) -> T
+ where
+ E: fmt::Debug,
+ {
match self {
- Ok(_) => res,
- Err(e) => Err(e),
+ Ok(t) => t,
+ Err(e) => unwrap_failed(msg, &e),
}
}
- /// Calls `op` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.
+ /// Returns the contained [`Ok`] value, consuming the `self` value.
+ ///
+ /// Because this function may panic, its use is generally discouraged.
+ /// Instead, prefer to use pattern matching and handle the [`Err`]
+ /// case explicitly, or call [`unwrap_or`], [`unwrap_or_else`], or
+ /// [`unwrap_or_default`].
///
+ /// [`unwrap_or`]: Result::unwrap_or
+ /// [`unwrap_or_else`]: Result::unwrap_or_else
+ /// [`unwrap_or_default`]: Result::unwrap_or_default
+ ///
+ /// # Panics
+ ///
+ /// Panics if the value is an [`Err`], with a panic message provided by the
+ /// [`Err`]'s value.
///
- /// This function can be used for control flow based on `Result` values.
///
/// # Examples
///
/// Basic usage:
///
/// ```
- /// fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
- /// fn err(x: u32) -> Result<u32, u32> { Err(x) }
+ /// let x: Result<u32, &str> = Ok(2);
+ /// assert_eq!(x.unwrap(), 2);
+ /// ```
///
- /// assert_eq!(Ok(2).and_then(sq).and_then(sq), Ok(16));
- /// assert_eq!(Ok(2).and_then(sq).and_then(err), Err(4));
- /// assert_eq!(Ok(2).and_then(err).and_then(sq), Err(2));
- /// assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));
+ /// ```should_panic
+ /// let x: Result<u32, &str> = Err("emergency failure");
+ /// x.unwrap(); // panics with `emergency failure`
/// ```
#[inline]
+ #[track_caller]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E> {
+ pub fn unwrap(self) -> T
+ where
+ E: fmt::Debug,
+ {
match self {
- Ok(t) => op(t),
- Err(e) => Err(e),
+ Ok(t) => t,
+ Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", &e),
}
}
- /// Returns `res` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.
- ///
- /// Arguments passed to `or` are eagerly evaluated; if you are passing the
- /// result of a function call, it is recommended to use [`or_else`], which is
- /// lazily evaluated.
+ /// Returns the contained [`Ok`] value or a default
///
- /// [`or_else`]: Result::or_else
+ /// Consumes the `self` argument then, if [`Ok`], returns the contained
+ /// value, otherwise if [`Err`], returns the default value for that
+ /// type.
///
/// # Examples
///
- /// Basic usage:
+ /// Converts a string to an integer, turning poorly-formed strings
+ /// into 0 (the default value for integers). [`parse`] converts
+ /// a string to any other type that implements [`FromStr`], returning an
+ /// [`Err`] on error.
///
/// ```
- /// 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 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();
///
- /// let x: Result<u32, &str> = Ok(2);
- /// let y: Result<u32, &str> = Ok(100);
- /// assert_eq!(x.or(y), Ok(2));
+ /// assert_eq!(1909, good_year);
+ /// assert_eq!(0, bad_year);
/// ```
+ ///
+ /// [`parse`]: str::parse
+ /// [`FromStr`]: crate::str::FromStr
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn or<F>(self, res: Result<T, F>) -> Result<T, F> {
+ #[stable(feature = "result_unwrap_or_default", since = "1.16.0")]
+ pub fn unwrap_or_default(self) -> T
+ where
+ T: Default,
+ {
match self {
- Ok(v) => Ok(v),
- Err(_) => res,
+ Ok(x) => x,
+ Err(_) => Default::default(),
}
}
- /// Calls `op` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.
+ /// Returns the contained [`Err`] value, consuming the `self` value.
///
- /// This function can be used for control flow based on result values.
+ /// # Panics
+ ///
+ /// Panics if the value is an [`Ok`], with a panic message including the
+ /// passed message, and the content of the [`Ok`].
///
///
/// # Examples
///
/// Basic usage:
///
- /// ```
- /// 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));
+ /// ```should_panic
+ /// let x: Result<u32, &str> = Ok(10);
+ /// x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
/// ```
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F> {
+ #[track_caller]
+ #[stable(feature = "result_expect_err", since = "1.17.0")]
+ pub fn expect_err(self, msg: &str) -> E
+ where
+ T: fmt::Debug,
+ {
match self {
- Ok(t) => Ok(t),
- Err(e) => op(e),
+ Ok(t) => unwrap_failed(msg, &t),
+ Err(e) => e,
}
}
- /// Returns the contained [`Ok`] value or a provided default.
+ /// Returns the contained [`Err`] value, consuming the `self` value.
///
- /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing
- /// the result of a function call, it is recommended to use [`unwrap_or_else`],
- /// which is lazily evaluated.
+ /// # Panics
///
- /// [`unwrap_or_else`]: Result::unwrap_or_else
+ /// Panics if the value is an [`Ok`], with a custom panic message provided
+ /// by the [`Ok`]'s value.
///
/// # Examples
///
- /// Basic usage:
- ///
+ /// ```should_panic
+ /// let x: Result<u32, &str> = Ok(2);
+ /// x.unwrap_err(); // panics with `2`
/// ```
- /// 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);
+ /// ```
+ /// let x: Result<u32, &str> = Err("emergency failure");
+ /// assert_eq!(x.unwrap_err(), "emergency failure");
/// ```
#[inline]
+ #[track_caller]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn unwrap_or(self, default: T) -> T {
+ pub fn unwrap_err(self) -> E
+ where
+ T: fmt::Debug,
+ {
match self {
- Ok(t) => t,
- Err(_) => default,
+ Ok(t) => unwrap_failed("called `Result::unwrap_err()` on an `Ok` value", &t),
+ Err(e) => e,
}
}
- /// Returns the contained [`Ok`] value or computes it from a closure.
+ /// Returns the contained [`Ok`] value, but never panics.
+ ///
+ /// Unlike [`unwrap`], this method is known to never panic on the
+ /// result types it is implemented for. Therefore, it can be used
+ /// instead of `unwrap` as a maintainability safeguard that will fail
+ /// to compile if the error type of the `Result` is later changed
+ /// to an error that can actually occur.
///
+ /// [`unwrap`]: Result::unwrap
///
/// # Examples
///
/// Basic usage:
///
/// ```
- /// fn count(x: &str) -> usize { x.len() }
+ /// # #![feature(never_type)]
+ /// # #![feature(unwrap_infallible)]
///
- /// assert_eq!(Ok(2).unwrap_or_else(count), 2);
- /// assert_eq!(Err("foo").unwrap_or_else(count), 3);
+ /// fn only_good_news() -> Result<String, !> {
+ /// Ok("this is fine".into())
+ /// }
+ ///
+ /// let s: String = only_good_news().into_ok();
+ /// println!("{}", s);
/// ```
+ #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
#[inline]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T {
+ pub fn into_ok(self) -> T
+ where
+ E: Into<!>,
+ {
match self {
- Ok(t) => t,
- Err(e) => op(e),
+ Ok(x) => x,
+ Err(e) => e.into(),
}
}
- /// Returns the contained [`Ok`] value, consuming the `self` value,
- /// without checking that the value is not an [`Err`].
- ///
- /// # Safety
+ /// Returns the contained [`Err`] value, but never panics.
///
- /// Calling this method on an [`Err`] is *[undefined behavior]*.
+ /// Unlike [`unwrap_err`], this method is known to never panic on the
+ /// result types it is implemented for. Therefore, it can be used
+ /// instead of `unwrap_err` as a maintainability safeguard that will fail
+ /// to compile if the ok type of the `Result` is later changed
+ /// to a type that can actually occur.
///
- /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
+ /// [`unwrap_err`]: Result::unwrap_err
///
/// # Examples
///
+ /// Basic usage:
+ ///
/// ```
- /// let x: Result<u32, &str> = Ok(2);
- /// assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
- /// ```
+ /// # #![feature(never_type)]
+ /// # #![feature(unwrap_infallible)]
///
- /// ```no_run
- /// let x: Result<u32, &str> = Err("emergency failure");
- /// unsafe { x.unwrap_unchecked(); } // Undefined behavior!
+ /// fn only_bad_news() -> Result<!, String> {
+ /// Err("Oops, it failed".into())
+ /// }
+ ///
+ /// let error: String = only_bad_news().into_err();
+ /// println!("{}", error);
/// ```
+ #[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
#[inline]
- #[track_caller]
- #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
- pub unsafe fn unwrap_unchecked(self) -> T {
- debug_assert!(self.is_ok());
+ pub fn into_err(self) -> E
+ where
+ T: Into<!>,
+ {
match self {
- Ok(t) => t,
- // SAFETY: the safety contract must be upheld by the caller.
- Err(_) => unsafe { hint::unreachable_unchecked() },
+ Ok(x) => x.into(),
+ Err(e) => e,
}
}
- /// Returns the contained [`Err`] value, consuming the `self` value,
- /// without checking that the value is not an [`Ok`].
- ///
- /// # Safety
- ///
- /// Calling this method on an [`Ok`] is *[undefined behavior]*.
+ ////////////////////////////////////////////////////////////////////////
+ // Boolean operations on the values, eager and lazy
+ /////////////////////////////////////////////////////////////////////////
+
+ /// Returns `res` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.
///
- /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
///
/// # Examples
///
- /// ```no_run
- /// let x: Result<u32, &str> = Ok(2);
- /// unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
- /// ```
+ /// Basic usage:
///
/// ```
- /// let x: Result<u32, &str> = Err("emergency failure");
- /// assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
+ /// 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"));
/// ```
#[inline]
- #[track_caller]
- #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
- pub unsafe fn unwrap_err_unchecked(self) -> E {
- debug_assert!(self.is_err());
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn and<U>(self, res: Result<U, E>) -> Result<U, E> {
match self {
- // SAFETY: the safety contract must be upheld by the caller.
- Ok(_) => unsafe { hint::unreachable_unchecked() },
- Err(e) => e,
+ Ok(_) => res,
+ Err(e) => Err(e),
}
}
-}
-impl<T: Copy, E> Result<&T, E> {
- /// Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the
- /// `Ok` part.
+ /// Calls `op` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.
///
- /// # Examples
///
- /// ```
- /// #![feature(result_copied)]
- /// let val = 12;
- /// let x: Result<&i32, i32> = Ok(&val);
- /// assert_eq!(x, Ok(&12));
- /// let copied = x.copied();
- /// assert_eq!(copied, Ok(12));
- /// ```
- #[unstable(feature = "result_copied", reason = "newly added", issue = "63168")]
- pub fn copied(self) -> Result<T, E> {
- self.map(|&t| t)
- }
-}
-
-impl<T: Copy, E> Result<&mut T, E> {
- /// Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the
- /// `Ok` part.
+ /// This function can be used for control flow based on `Result` values.
///
/// # Examples
///
+ /// Basic usage:
+ ///
/// ```
- /// #![feature(result_copied)]
- /// 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));
+ /// fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }
+ /// fn err(x: u32) -> Result<u32, u32> { Err(x) }
+ ///
+ /// assert_eq!(Ok(2).and_then(sq).and_then(sq), Ok(16));
+ /// assert_eq!(Ok(2).and_then(sq).and_then(err), Err(4));
+ /// assert_eq!(Ok(2).and_then(err).and_then(sq), Err(2));
+ /// assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));
/// ```
- #[unstable(feature = "result_copied", reason = "newly added", issue = "63168")]
- pub fn copied(self) -> Result<T, E> {
- self.map(|&mut t| t)
+ #[inline]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E> {
+ match self {
+ Ok(t) => op(t),
+ Err(e) => Err(e),
+ }
}
-}
-impl<T: Clone, E> Result<&T, E> {
- /// Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the
- /// `Ok` part.
+ /// Returns `res` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.
///
- /// # Examples
+ /// Arguments passed to `or` are eagerly evaluated; if you are passing the
+ /// result of a function call, it is recommended to use [`or_else`], which is
+ /// lazily evaluated.
///
- /// ```
- /// #![feature(result_cloned)]
- /// let val = 12;
- /// let x: Result<&i32, i32> = Ok(&val);
- /// assert_eq!(x, Ok(&12));
- /// let cloned = x.cloned();
- /// assert_eq!(cloned, Ok(12));
- /// ```
- #[unstable(feature = "result_cloned", reason = "newly added", issue = "63168")]
- pub fn cloned(self) -> Result<T, E> {
- self.map(|t| t.clone())
- }
-}
-
-impl<T: Clone, E> Result<&mut T, E> {
- /// Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the
- /// `Ok` part.
+ /// [`or_else`]: Result::or_else
///
/// # Examples
///
+ /// Basic usage:
+ ///
/// ```
- /// #![feature(result_cloned)]
- /// 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));
+ /// 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));
/// ```
- #[unstable(feature = "result_cloned", reason = "newly added", issue = "63168")]
- pub fn cloned(self) -> Result<T, E> {
- self.map(|t| t.clone())
+ #[inline]
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn or<F>(self, res: Result<T, F>) -> Result<T, F> {
+ match self {
+ Ok(v) => Ok(v),
+ Err(_) => res,
+ }
}
-}
-impl<T, E: fmt::Debug> Result<T, E> {
- /// Returns the contained [`Ok`] value, consuming the `self` value.
- ///
- /// # Panics
+ /// Calls `op` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.
///
- /// Panics if the value is an [`Err`], with a panic message including the
- /// passed message, and the content of the [`Err`].
+ /// This function can be used for control flow based on result values.
///
///
/// # Examples
///
/// Basic usage:
///
- /// ```should_panic
- /// let x: Result<u32, &str> = Err("emergency failure");
- /// x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
+ /// ```
+ /// 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));
/// ```
#[inline]
- #[track_caller]
- #[stable(feature = "result_expect", since = "1.4.0")]
- pub fn expect(self, msg: &str) -> T {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F> {
match self {
- Ok(t) => t,
- Err(e) => unwrap_failed(msg, &e),
+ Ok(t) => Ok(t),
+ Err(e) => op(e),
}
}
- /// Returns the contained [`Ok`] value, consuming the `self` value.
+ /// Returns the contained [`Ok`] value or a provided default.
///
- /// Because this function may panic, its use is generally discouraged.
- /// Instead, prefer to use pattern matching and handle the [`Err`]
- /// case explicitly, or call [`unwrap_or`], [`unwrap_or_else`], or
- /// [`unwrap_or_default`].
+ /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing
+ /// the result of a function call, it is recommended to use [`unwrap_or_else`],
+ /// which is lazily evaluated.
///
- /// [`unwrap_or`]: Result::unwrap_or
/// [`unwrap_or_else`]: Result::unwrap_or_else
- /// [`unwrap_or_default`]: Result::unwrap_or_default
- ///
- /// # Panics
- ///
- /// Panics if the value is an [`Err`], with a panic message provided by the
- /// [`Err`]'s value.
- ///
///
/// # Examples
///
/// Basic usage:
///
/// ```
- /// let x: Result<u32, &str> = Ok(2);
- /// assert_eq!(x.unwrap(), 2);
- /// ```
+ /// let default = 2;
+ /// let x: Result<u32, &str> = Ok(9);
+ /// assert_eq!(x.unwrap_or(default), 9);
///
- /// ```should_panic
- /// let x: Result<u32, &str> = Err("emergency failure");
- /// x.unwrap(); // panics with `emergency failure`
+ /// let x: Result<u32, &str> = Err("error");
+ /// assert_eq!(x.unwrap_or(default), default);
/// ```
#[inline]
- #[track_caller]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn unwrap(self) -> T {
+ pub fn unwrap_or(self, default: T) -> T {
match self {
Ok(t) => t,
- Err(e) => unwrap_failed("called `Result::unwrap()` on an `Err` value", &e),
+ Err(_) => default,
}
}
-}
-impl<T: fmt::Debug, E> Result<T, E> {
- /// Returns the contained [`Err`] value, consuming the `self` value.
- ///
- /// # Panics
- ///
- /// Panics if the value is an [`Ok`], with a panic message including the
- /// passed message, and the content of the [`Ok`].
+ /// Returns the contained [`Ok`] value or computes it from a closure.
///
///
/// # Examples
///
/// Basic usage:
///
- /// ```should_panic
- /// let x: Result<u32, &str> = Ok(10);
- /// x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
+ /// ```
+ /// 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);
/// ```
#[inline]
- #[track_caller]
- #[stable(feature = "result_expect_err", since = "1.17.0")]
- pub fn expect_err(self, msg: &str) -> E {
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T {
match self {
- Ok(t) => unwrap_failed(msg, &t),
- Err(e) => e,
+ Ok(t) => t,
+ Err(e) => op(e),
}
}
- /// Returns the contained [`Err`] value, consuming the `self` value.
+ /// Returns the contained [`Ok`] value, consuming the `self` value,
+ /// without checking that the value is not an [`Err`].
///
- /// # Panics
+ /// # Safety
///
- /// Panics if the value is an [`Ok`], with a custom panic message provided
- /// by the [`Ok`]'s value.
+ /// Calling this method on an [`Err`] is *[undefined behavior]*.
+ ///
+ /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
///
/// # Examples
///
- /// ```should_panic
+ /// ```
/// let x: Result<u32, &str> = Ok(2);
- /// x.unwrap_err(); // panics with `2`
+ /// assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
/// ```
///
- /// ```
+ /// ```no_run
/// let x: Result<u32, &str> = Err("emergency failure");
- /// assert_eq!(x.unwrap_err(), "emergency failure");
+ /// unsafe { x.unwrap_unchecked(); } // Undefined behavior!
/// ```
#[inline]
#[track_caller]
- #[stable(feature = "rust1", since = "1.0.0")]
- pub fn unwrap_err(self) -> E {
+ #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
+ pub unsafe fn unwrap_unchecked(self) -> T {
+ debug_assert!(self.is_ok());
match self {
- Ok(t) => unwrap_failed("called `Result::unwrap_err()` on an `Ok` value", &t),
- Err(e) => e,
+ Ok(t) => t,
+ // SAFETY: the safety contract must be upheld by the caller.
+ Err(_) => unsafe { hint::unreachable_unchecked() },
}
}
-}
-impl<T: Default, E> Result<T, E> {
- /// Returns the contained [`Ok`] value or a default
+ /// Returns the contained [`Err`] value, consuming the `self` value,
+ /// without checking that the value is not an [`Ok`].
///
- /// Consumes the `self` argument then, if [`Ok`], returns the contained
- /// value, otherwise if [`Err`], returns the default value for that
- /// type.
+ /// # Safety
///
- /// # Examples
+ /// Calling this method on an [`Ok`] is *[undefined behavior]*.
///
- /// Converts a string to an integer, turning poorly-formed strings
- /// into 0 (the default value for integers). [`parse`] converts
- /// a string to any other type that implements [`FromStr`], returning an
- /// [`Err`] on error.
+ /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
///
- /// ```
- /// 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();
+ /// # Examples
///
- /// assert_eq!(1909, good_year);
- /// assert_eq!(0, bad_year);
+ /// ```no_run
+ /// let x: Result<u32, &str> = Ok(2);
+ /// unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
/// ```
///
- /// [`parse`]: str::parse
- /// [`FromStr`]: crate::str::FromStr
+ /// ```
+ /// let x: Result<u32, &str> = Err("emergency failure");
+ /// assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
+ /// ```
#[inline]
- #[stable(feature = "result_unwrap_or_default", since = "1.16.0")]
- pub fn unwrap_or_default(self) -> T {
+ #[track_caller]
+ #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
+ pub unsafe fn unwrap_err_unchecked(self) -> E {
+ debug_assert!(self.is_err());
match self {
- Ok(x) => x,
- Err(_) => Default::default(),
+ // SAFETY: the safety contract must be upheld by the caller.
+ Ok(_) => unsafe { hint::unreachable_unchecked() },
+ Err(e) => e,
}
}
}
-#[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
-impl<T, E: Into<!>> Result<T, E> {
- /// Returns the contained [`Ok`] value, but never panics.
- ///
- /// Unlike [`unwrap`], this method is known to never panic on the
- /// result types it is implemented for. Therefore, it can be used
- /// instead of `unwrap` as a maintainability safeguard that will fail
- /// to compile if the error type of the `Result` is later changed
- /// to an error that can actually occur.
- ///
- /// [`unwrap`]: Result::unwrap
+impl<T, E> Result<&T, E> {
+ /// Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the
+ /// `Ok` part.
///
/// # Examples
///
- /// Basic usage:
- ///
/// ```
- /// # #![feature(never_type)]
- /// # #![feature(unwrap_infallible)]
- ///
- /// fn only_good_news() -> Result<String, !> {
- /// Ok("this is fine".into())
- /// }
- ///
- /// let s: String = only_good_news().into_ok();
- /// println!("{}", s);
+ /// #![feature(result_copied)]
+ /// let val = 12;
+ /// let x: Result<&i32, i32> = Ok(&val);
+ /// assert_eq!(x, Ok(&12));
+ /// let copied = x.copied();
+ /// assert_eq!(copied, Ok(12));
/// ```
- #[inline]
- pub fn into_ok(self) -> T {
- match self {
- Ok(x) => x,
- Err(e) => e.into(),
- }
+ #[unstable(feature = "result_copied", reason = "newly added", issue = "63168")]
+ pub fn copied(self) -> Result<T, E>
+ where
+ T: Copy,
+ {
+ self.map(|&t| t)
}
-}
-#[unstable(feature = "unwrap_infallible", reason = "newly added", issue = "61695")]
-impl<T: Into<!>, E> Result<T, E> {
- /// Returns the contained [`Err`] value, but never panics.
- ///
- /// Unlike [`unwrap_err`], this method is known to never panic on the
- /// result types it is implemented for. Therefore, it can be used
- /// instead of `unwrap_err` as a maintainability safeguard that will fail
- /// to compile if the ok type of the `Result` is later changed
- /// to a type that can actually occur.
- ///
- /// [`unwrap_err`]: Result::unwrap_err
+ /// Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the
+ /// `Ok` part.
///
/// # Examples
///
- /// Basic usage:
- ///
/// ```
- /// # #![feature(never_type)]
- /// # #![feature(unwrap_infallible)]
- ///
- /// fn only_bad_news() -> Result<!, String> {
- /// Err("Oops, it failed".into())
- /// }
- ///
- /// let error: String = only_bad_news().into_err();
- /// println!("{}", error);
+ /// #![feature(result_cloned)]
+ /// let val = 12;
+ /// let x: Result<&i32, i32> = Ok(&val);
+ /// assert_eq!(x, Ok(&12));
+ /// let cloned = x.cloned();
+ /// assert_eq!(cloned, Ok(12));
/// ```
- #[inline]
- pub fn into_err(self) -> E {
- match self {
- Ok(x) => x.into(),
- Err(e) => e,
- }
+ #[unstable(feature = "result_cloned", reason = "newly added", issue = "63168")]
+ pub fn cloned(self) -> Result<T, E>
+ where
+ T: Clone,
+ {
+ self.map(|t| t.clone())
}
}
-impl<T: Deref, E> Result<T, E> {
- /// Converts from `Result<T, E>` (or `&Result<T, E>`) to `Result<&<T as Deref>::Target, &E>`.
- ///
- /// Coerces the [`Ok`] variant of the original [`Result`] via [`Deref`](crate::ops::Deref)
- /// and returns the new [`Result`].
+impl<T, E> Result<&mut T, E> {
+ /// Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the
+ /// `Ok` part.
///
/// # 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);
+ /// #![feature(result_copied)]
+ /// 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));
/// ```
- #[stable(feature = "inner_deref", since = "1.47.0")]
- pub fn as_deref(&self) -> Result<&T::Target, &E> {
- self.as_ref().map(|t| t.deref())
+ #[unstable(feature = "result_copied", reason = "newly added", issue = "63168")]
+ pub fn copied(self) -> Result<T, E>
+ where
+ T: Copy,
+ {
+ self.map(|&mut t| t)
}
-}
-impl<T: DerefMut, E> Result<T, E> {
- /// Converts from `Result<T, E>` (or `&mut Result<T, E>`) to `Result<&mut <T as DerefMut>::Target, &mut E>`.
- ///
- /// Coerces the [`Ok`] variant of the original [`Result`] via [`DerefMut`](crate::ops::DerefMut)
- /// and returns the new [`Result`].
+ /// Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the
+ /// `Ok` part.
///
/// # 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);
+ /// #![feature(result_cloned)]
+ /// 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));
/// ```
- #[stable(feature = "inner_deref", since = "1.47.0")]
- pub fn as_deref_mut(&mut self) -> Result<&mut T::Target, &mut E> {
- self.as_mut().map(|t| t.deref_mut())
+ #[unstable(feature = "result_cloned", reason = "newly added", issue = "63168")]
+ pub fn cloned(self) -> Result<T, E>
+ where
+ T: Clone,
+ {
+ self.map(|t| t.clone())
}
}
diff --git a/src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr b/src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
index e4e9705b07db5..52ee1db5b1571 100644
--- a/src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
+++ b/src/test/ui/issues/issue-50264-inner-deref-trait/option-as_deref_mut.stderr
@@ -5,7 +5,6 @@ LL | let _result = &mut Some(42).as_deref_mut();
| ^^^^^^^^^^^^ method cannot be called on `Option<{integer}>` due to unsatisfied trait bounds
|
= note: the following trait bounds were not satisfied:
- `{integer}: DerefMut`
`{integer}: Deref`
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
index 98a7091dd0583..018557881ef77 100644
--- a/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
+++ b/src/test/ui/issues/issue-50264-inner-deref-trait/result-as_deref_mut.stderr
@@ -5,7 +5,6 @@ LL | let _result = &mut Ok(42).as_deref_mut();
| ^^^^^^^^^^^^ method cannot be called on `Result<{integer}, _>` due to unsatisfied trait bounds
|
= note: the following trait bounds were not satisfied:
- `{integer}: DerefMut`
`{integer}: Deref`
error: aborting due to previous error
diff --git a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.rs b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.rs
index f85c10d78c54d..6303c6e6a5db1 100644
--- a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.rs
+++ b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.rs
@@ -3,5 +3,5 @@ struct Foo;
fn main() {
let a: Result<(), Foo> = Ok(());
a.unwrap();
- //~^ ERROR the method
+ //~^ ERROR `Foo` doesn't implement `Debug`
}
diff --git a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr
index 596b7bfe79c5c..dc73bcd6e4d05 100644
--- a/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr
+++ b/src/test/ui/mismatched_types/method-help-unsatisfied-bound.stderr
@@ -1,19 +1,17 @@
-error[E0599]: the method `unwrap` exists for enum `Result<(), Foo>`, but its trait bounds were not satisfied
+error[E0277]: `Foo` doesn't implement `Debug`
--> $DIR/method-help-unsatisfied-bound.rs:5:7
|
-LL | struct Foo;
- | ----------- doesn't satisfy `Foo: Debug`
-...
LL | a.unwrap();
- | ^^^^^^ method cannot be called on `Result<(), Foo>` due to unsatisfied trait bounds
+ | ^^^^^^ `Foo` cannot be formatted using `{:?}`
|
- = note: the following trait bounds were not satisfied:
- `Foo: Debug`
-help: consider annotating `Foo` with `#[derive(Debug)]`
- |
-LL | #[derive(Debug)]
+ = help: the trait `Debug` is not implemented for `Foo`
+ = note: add `#[derive(Debug)]` to `Foo` or manually `impl Debug for Foo`
+note: required by a bound in `Result::<T, E>::unwrap`
+ --> $SRC_DIR/core/src/result.rs:LL:COL
|
+LL | E: fmt::Debug,
+ | ^^^^^^^^^^ required by this bound in `Result::<T, E>::unwrap`
error: aborting due to previous error
-For more information about this error, try `rustc --explain E0599`.
+For more information about this error, try `rustc --explain E0277`.