From 0eb67cfea00c19e7d0cf1981acc805986dfd05d6 Mon Sep 17 00:00:00 2001
From: Jason Volk <jason@zemos.net>
Date: Wed, 30 Oct 2024 06:41:03 +0000
Subject: [PATCH] additional bool extensions for Result/Option conversion

Signed-off-by: Jason Volk <jason@zemos.net>
---
 src/core/utils/bool.rs | 39 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/core/utils/bool.rs b/src/core/utils/bool.rs
index d5fa85aa..e9f399d4 100644
--- a/src/core/utils/bool.rs
+++ b/src/core/utils/bool.rs
@@ -2,6 +2,23 @@
 
 /// Boolean extensions and chain.starters
 pub trait BoolExt {
+	#[must_use]
+	fn clone_or<T: Clone>(self, err: T, t: &T) -> T;
+
+	#[must_use]
+	fn copy_or<T: Copy>(self, err: T, t: T) -> T;
+
+	#[must_use]
+	fn expect(self, msg: &str) -> Self;
+
+	#[must_use]
+	fn expect_false(self, msg: &str) -> Self;
+
+	fn into_option(self) -> Option<()>;
+
+	#[allow(clippy::result_unit_err)]
+	fn into_result(self) -> Result<(), ()>;
+
 	fn map<T, F: FnOnce(Self) -> T>(self, f: F) -> T
 	where
 		Self: Sized;
@@ -22,6 +39,24 @@ pub trait BoolExt {
 }
 
 impl BoolExt for bool {
+	#[inline]
+	fn clone_or<T: Clone>(self, err: T, t: &T) -> T { self.map_or(err, || t.clone()) }
+
+	#[inline]
+	fn copy_or<T: Copy>(self, err: T, t: T) -> T { self.map_or(err, || t) }
+
+	#[inline]
+	fn expect(self, msg: &str) -> Self { self.then_some(true).expect(msg) }
+
+	#[inline]
+	fn expect_false(self, msg: &str) -> Self { (!self).then_some(false).expect(msg) }
+
+	#[inline]
+	fn into_option(self) -> Option<()> { self.then_some(()) }
+
+	#[inline]
+	fn into_result(self) -> Result<(), ()> { self.ok_or(()) }
+
 	#[inline]
 	fn map<T, F: FnOnce(Self) -> T>(self, f: F) -> T
 	where
@@ -40,10 +75,10 @@ impl BoolExt for bool {
 	fn map_or_else<T, F: FnOnce() -> T>(self, err: F, f: F) -> T { self.then(f).unwrap_or_else(err) }
 
 	#[inline]
-	fn ok_or<E>(self, err: E) -> Result<(), E> { self.then_some(()).ok_or(err) }
+	fn ok_or<E>(self, err: E) -> Result<(), E> { self.into_option().ok_or(err) }
 
 	#[inline]
-	fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<(), E> { self.then_some(()).ok_or_else(err) }
+	fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<(), E> { self.into_option().ok_or_else(err) }
 
 	#[inline]
 	fn or<T, F: FnOnce() -> T>(self, f: F) -> Option<T> { (!self).then(f) }