From 4b8da41797bc9129148bedbd78db670959cd420d Mon Sep 17 00:00:00 2001
From: LimpSquid <git@limpsquid.nl>
Date: Wed, 16 Jul 2025 20:58:26 +0200
Subject: [PATCH] Rename bool::ok_or[_else] to bool::then_ok_or[_else]

Rename bool to result methods in order to avoid confusion with
Option::ok_or[_else].
---
 library/core/src/bool.rs        | 30 +++++++++++++++---------------
 library/coretests/tests/bool.rs |  8 ++++----
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/library/core/src/bool.rs b/library/core/src/bool.rs
index 99268d6182f6c..f0cb0da912069 100644
--- a/library/core/src/bool.rs
+++ b/library/core/src/bool.rs
@@ -65,19 +65,19 @@ impl bool {
     /// Returns `Ok(())` if the `bool` is [`true`](../std/keyword.true.html),
     /// or `Err(err)` otherwise.
     ///
-    /// Arguments passed to `ok_or` are eagerly evaluated; if you are
+    /// Arguments passed to `then_ok_or` are eagerly evaluated; if you are
     /// passing the result of a function call, it is recommended to use
-    /// [`ok_or_else`], which is lazily evaluated.
+    /// [`then_ok_or_else`], which is lazily evaluated.
     ///
-    /// [`ok_or_else`]: bool::ok_or_else
+    /// [`then_ok_or_else`]: bool::then_ok_or_else
     ///
     /// # Examples
     ///
     /// ```
     /// #![feature(bool_to_result)]
     ///
-    /// assert_eq!(false.ok_or(0), Err(0));
-    /// assert_eq!(true.ok_or(0), Ok(()));
+    /// assert_eq!(false.then_ok_or(0), Err(0));
+    /// assert_eq!(true.then_ok_or(0), Ok(()));
     /// ```
     ///
     /// ```
@@ -86,16 +86,16 @@ impl bool {
     /// let mut a = 0;
     /// let mut function_with_side_effects = || { a += 1; };
     ///
-    /// assert!(true.ok_or(function_with_side_effects()).is_ok());
-    /// assert!(false.ok_or(function_with_side_effects()).is_err());
+    /// assert!(true.then_ok_or(function_with_side_effects()).is_ok());
+    /// assert!(false.then_ok_or(function_with_side_effects()).is_err());
     ///
-    /// // `a` is incremented twice because the value passed to `ok_or` is
+    /// // `a` is incremented twice because the value passed to `then_ok_or` is
     /// // evaluated eagerly.
     /// assert_eq!(a, 2);
     /// ```
     #[unstable(feature = "bool_to_result", issue = "142748")]
     #[inline]
-    pub fn ok_or<E>(self, err: E) -> Result<(), E> {
+    pub fn then_ok_or<E>(self, err: E) -> Result<(), E> {
         if self { Ok(()) } else { Err(err) }
     }
 
@@ -107,8 +107,8 @@ impl bool {
     /// ```
     /// #![feature(bool_to_result)]
     ///
-    /// assert_eq!(false.ok_or_else(|| 0), Err(0));
-    /// assert_eq!(true.ok_or_else(|| 0), Ok(()));
+    /// assert_eq!(false.then_ok_or_else(|| 0), Err(0));
+    /// assert_eq!(true.then_ok_or_else(|| 0), Ok(()));
     /// ```
     ///
     /// ```
@@ -116,16 +116,16 @@ impl bool {
     ///
     /// let mut a = 0;
     ///
-    /// assert!(true.ok_or_else(|| { a += 1; }).is_ok());
-    /// assert!(false.ok_or_else(|| { a += 1; }).is_err());
+    /// assert!(true.then_ok_or_else(|| { a += 1; }).is_ok());
+    /// assert!(false.then_ok_or_else(|| { a += 1; }).is_err());
     ///
     /// // `a` is incremented once because the closure is evaluated lazily by
-    /// // `ok_or_else`.
+    /// // `then_ok_or_else`.
     /// assert_eq!(a, 1);
     /// ```
     #[unstable(feature = "bool_to_result", issue = "142748")]
     #[inline]
-    pub fn ok_or_else<E, F: FnOnce() -> E>(self, f: F) -> Result<(), E> {
+    pub fn then_ok_or_else<E, F: FnOnce() -> E>(self, f: F) -> Result<(), E> {
         if self { Ok(()) } else { Err(f()) }
     }
 }
diff --git a/library/coretests/tests/bool.rs b/library/coretests/tests/bool.rs
index eb5f0f50663e1..dab9f571d542b 100644
--- a/library/coretests/tests/bool.rs
+++ b/library/coretests/tests/bool.rs
@@ -108,8 +108,8 @@ fn test_bool_to_option() {
 
 #[test]
 fn test_bool_to_result() {
-    assert_eq!(false.ok_or(0), Err(0));
-    assert_eq!(true.ok_or(0), Ok(()));
-    assert_eq!(false.ok_or_else(|| 0), Err(0));
-    assert_eq!(true.ok_or_else(|| 0), Ok(()));
+    assert_eq!(false.then_ok_or(0), Err(0));
+    assert_eq!(true.then_ok_or(0), Ok(()));
+    assert_eq!(false.then_ok_or_else(|| 0), Err(0));
+    assert_eq!(true.then_ok_or_else(|| 0), Ok(()));
 }