Auto merge of #98354 - camsteffen:is-some-and-by-value, r=m-ou-se

Change `is_some_and` to take by value

Consistent with other function-accepting `Option` methods.

Tracking issue: #93050

r? `@m-ou-se`

compiler/rustc_builtin_macros/src/lib.rs

@@ -7,7 +7,7 @@
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(if_let_guard)]
-#![feature(is_some_with)]
+#![feature(is_some_and)]
 #![feature(is_sorted)]
 #![feature(let_chains)]
 #![feature(proc_macro_internals)]

compiler/rustc_const_eval/src/lib.rs

@@ -20,7 +20,7 @@ Rust MIR: a lowered representation of Rust.
 #![feature(trusted_step)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
-#![feature(is_some_with)]
+#![feature(is_some_and)]
 #![recursion_limit = "256"]
 #![allow(rustc::potential_query_instability)]
 

compiler/rustc_hir_analysis/src/lib.rs

@@ -70,7 +70,7 @@ This API is completely unstable and subject to change.
 #![feature(once_cell)]
 #![feature(slice_partition_dedup)]
 #![feature(try_blocks)]
-#![feature(is_some_with)]
+#![feature(is_some_and)]
 #![feature(type_alias_impl_trait)]
 #![recursion_limit = "256"]
 

library/core/src/option.rs

@@ -559,22 +559,25 @@ impl<T> Option<T> {
  /// # Examples
  ///
  /// ```
- /// #![feature(is_some_with)]
+ /// #![feature(is_some_and)]
  ///
  /// let x: Option<u32> = Some(2);
- /// assert_eq!(x.is_some_and(|&x| x > 1), true);
+ /// assert_eq!(x.is_some_and(|x| x > 1), true);
  ///
  /// let x: Option<u32> = Some(0);
- /// assert_eq!(x.is_some_and(|&x| x > 1), false);
+ /// assert_eq!(x.is_some_and(|x| x > 1), false);
  ///
  /// let x: Option<u32> = None;
- /// assert_eq!(x.is_some_and(|&x| x > 1), false);
+ /// assert_eq!(x.is_some_and(|x| x > 1), false);
  /// ```
  #[must_use]
  #[inline]
- #[unstable(feature = "is_some_with", issue = "93050")]
- pub fn is_some_and(&self, f: impl FnOnce(&T) -> bool) -> bool {
- matches!(self, Some(x) if f(x))
+ #[unstable(feature = "is_some_and", issue = "93050")]
+ pub fn is_some_and(self, f: impl FnOnce(T) -> bool) -> bool {
+ match self {
+ None => false,
+ Some(x) => f(x),
+ }
  }
 
  /// Returns `true` if the option is a [`None`] value.

library/core/src/result.rs

@@ -548,22 +548,25 @@ impl<T, E> Result<T, E> {
  /// # Examples
  ///
  /// ```
- /// #![feature(is_some_with)]
+ /// #![feature(is_some_and)]
  ///
  /// let x: Result<u32, &str> = Ok(2);
- /// assert_eq!(x.is_ok_and(|&x| x > 1), true);
+ /// assert_eq!(x.is_ok_and(|x| x > 1), true);
  ///
  /// let x: Result<u32, &str> = Ok(0);
- /// assert_eq!(x.is_ok_and(|&x| x > 1), false);
+ /// assert_eq!(x.is_ok_and(|x| x > 1), false);
  ///
  /// let x: Result<u32, &str> = Err("hey");
- /// assert_eq!(x.is_ok_and(|&x| x > 1), false);
+ /// assert_eq!(x.is_ok_and(|x| x > 1), false);
  /// ```
  #[must_use]
  #[inline]
- #[unstable(feature = "is_some_with", issue = "93050")]
- pub fn is_ok_and(&self, f: impl FnOnce(&T) -> bool) -> bool {
- matches!(self, Ok(x) if f(x))
+ #[unstable(feature = "is_some_and", issue = "93050")]
+ pub fn is_ok_and(self, f: impl FnOnce(T) -> bool) -> bool {
+ match self {
+ Err(_) => false,
+ Ok(x) => f(x),
+ }
  }
 
  /// Returns `true` if the result is [`Err`].
@@ -592,7 +595,7 @@ impl<T, E> Result<T, E> {
  /// # Examples
  ///
  /// ```
- /// #![feature(is_some_with)]
+ /// #![feature(is_some_and)]
  /// use std::io::{Error, ErrorKind};
  ///
  /// let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
@@ -606,9 +609,12 @@ impl<T, E> Result<T, E> {
  /// ```
  #[must_use]
  #[inline]
- #[unstable(feature = "is_some_with", issue = "93050")]
- pub fn is_err_and(&self, f: impl FnOnce(&E) -> bool) -> bool {
- matches!(self, Err(x) if f(x))
+ #[unstable(feature = "is_some_and", issue = "93050")]
+ pub fn is_err_and(self, f: impl FnOnce(E) -> bool) -> bool {
+ match self {
+ Ok(_) => false,
+ Err(e) => f(e),
+ }
  }
 
  /////////////////////////////////////////////////////////////////////////

library/std/src/lib.rs

@@ -292,7 +292,7 @@
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
 #![feature(int_error_internals)]
-#![feature(is_some_with)]
+#![feature(is_some_and)]
 #![feature(maybe_uninit_slice)]
 #![feature(maybe_uninit_write_slice)]
 #![feature(nonnull_slice_from_raw_parts)]

src/tools/miri/src/lib.rs

@@ -7,7 +7,7 @@
 #![feature(int_log)]
 #![feature(variant_count)]
 #![feature(yeet_expr)]
-#![feature(is_some_with)]
+#![feature(is_some_and)]
 #![feature(nonzero_ops)]
 #![feature(local_key_cell_methods)]
 #![cfg_attr(bootstrap, feature(let_else))]

src/tools/miri/src/stacked_borrows/stack.rs

@@ -211,7 +211,7 @@ impl<'tcx> Stack {
  }
 
  // Couldn't find it in the stack; but if there is an unknown bottom it might be there.
- let found = self.unknown_bottom.is_some_and(|&unknown_limit| {
+ let found = self.unknown_bottom.is_some_and(|unknown_limit| {
  tag.0 < unknown_limit.0 // unknown_limit is an upper bound for what can be in the unknown bottom.
  });
  if found { Ok(None) } else { Err(()) }