// Getting to contained values
/////////////////////////////////////////////////////////////////////////
- /// Unwraps an option, yielding the content of a [`Some`].
+ /// Returns the contained [`Some`] value, consuming the `self` value.
///
/// # Panics
///
}
}
- /// Moves the value `v` out of the `Option<T>` if it is [`Some(v)`].
+ /// Returns the contained [`Some`] value, consuming the `self` value.
///
- /// In general, because this function may panic, its use is discouraged.
+ /// Because this function may panic, its use is generally discouraged.
/// Instead, prefer to use pattern matching and handle the [`None`]
- /// case explicitly.
+ /// case explicitly, or call [`unwrap_or`], [`unwrap_or_else`], or
+ /// [`unwrap_or_default`].
+ ///
+ /// [`unwrap_or`]: #method.unwrap_or
+ /// [`unwrap_or_else`]: #method.unwrap_or_else
+ /// [`unwrap_or_default`]: #method.unwrap_or_default
///
/// # Panics
///
/// Panics if the self value equals [`None`].
///
- /// [`Some(v)`]: #variant.Some
+ /// [`Some`]: #variant.Some
/// [`None`]: #variant.None
///
/// # Examples
}
}
- /// Returns the contained value or a default.
+ /// Returns the contained [`Some`] value or a provided 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.
///
+ /// [`Some`]: #variant.Some
/// [`unwrap_or_else`]: #method.unwrap_or_else
///
/// # Examples
}
}
- /// Returns the contained value or computes it from a closure.
+ /// Returns the contained [`Some`] value or computes it from a closure.
///
/// # Examples
///
pub fn replace(&mut self, value: T) -> Option<T> {
mem::replace(self, Some(value))
}
+
+ /// Zips `self` with another `Option`.
+ ///
+ /// If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some((s, o))`.
+ /// Otherwise, `None` is returned.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(option_zip)]
+ /// 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);
+ /// ```
+ #[unstable(feature = "option_zip", issue = "70086")]
+ pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)> {
+ self.zip_with(other, |a, b| (a, b))
+ }
+
+ /// Zips `self` and another `Option` with function `f`.
+ ///
+ /// If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some(f(s, o))`.
+ /// Otherwise, `None` is returned.
+ ///
+ /// # 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);
+ /// ```
+ #[unstable(feature = "option_zip", issue = "70086")]
+ pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>
+ where
+ F: FnOnce(T, U) -> R,
+ {
+ Some(f(self?, other?))
+ }
}
impl<T: Copy> Option<&T> {
}
impl<T: fmt::Debug> Option<T> {
- /// Unwraps an option, expecting [`None`] and returning nothing.
+ /// Consumes `self` while expecting [`None`] and returning nothing.
///
/// # Panics
///
}
}
- /// Unwraps an option, expecting [`None`] and returning nothing.
+ /// Consumes `self` while expecting [`None`] and returning nothing.
///
/// # Panics
///
}
impl<T: Default> Option<T> {
- /// Returns the contained value or a default
+ /// 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