From cf49f2900fe3c7abd1bbadacfdc745d6b5bbc235 Mon Sep 17 00:00:00 2001
From: Botahamec <botahamec@outlook.com>
Date: Tue, 21 May 2024 14:48:46 -0400
Subject: Fix the Dining Philosophers Problem

---
 examples/dining_philosophers.rs |  8 ++++++--
 src/lockable.rs                 | 16 ++++------------
 src/rwlock/read_lock.rs         |  4 ++--
 src/rwlock/write_lock.rs        |  8 ++++----
 4 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/examples/dining_philosophers.rs b/examples/dining_philosophers.rs
index 2f2fa0d..1340564 100644
--- a/examples/dining_philosophers.rs
+++ b/examples/dining_philosophers.rs
@@ -61,9 +61,13 @@ impl Philosopher {
 }
 
 fn main() {
-	let handles = PHILOSOPHERS
+	let handles: Vec<_> = PHILOSOPHERS
 		.iter()
-		.map(|philosopher| thread::spawn(move || philosopher.cycle()));
+		.map(|philosopher| thread::spawn(move || philosopher.cycle()))
+		// The `collect` is absolutely necessary, because we're using lazy
+		// iterators. If `collect` isn't used, then the thread won't spawn
+		// until we try to join on it.
+		.collect();
 
 	for handle in handles {
 		_ = handle.join();
diff --git a/src/lockable.rs b/src/lockable.rs
index a5646e1..9b3a4e4 100644
--- a/src/lockable.rs
+++ b/src/lockable.rs
@@ -124,7 +124,7 @@ unsafe impl<T: Send, R: RawMutex + Send + Sync> OwnedLockable for Mutex<T, R> {}
 
 unsafe impl<T: Send, R: RawRwLock + Send + Sync> OwnedLockable for RwLock<T, R> {}
 
-unsafe impl<T: Send, R: RawRwLock + Send + Sync> Lockable for ReadLock<T, R> {
+unsafe impl<'l, T: Send, R: RawRwLock + Send + Sync> Lockable for ReadLock<'l, T, R> {
 	type Guard<'g> = RwLockReadRef<'g, T, R> where Self: 'g;
 
 	fn get_ptrs<'a>(&'a self, ptrs: &mut Vec<&'a dyn Lock>) {
@@ -136,7 +136,7 @@ unsafe impl<T: Send, R: RawRwLock + Send + Sync> Lockable for ReadLock<T, R> {
 	}
 }
 
-unsafe impl<T: Send, R: RawRwLock + Send + Sync> Lockable for WriteLock<T, R> {
+unsafe impl<'l, T: Send, R: RawRwLock + Send + Sync> Lockable for WriteLock<'l, T, R> {
 	type Guard<'g> = RwLockWriteRef<'g, T, R> where Self: 'g;
 
 	fn get_ptrs<'a>(&'a self, ptrs: &mut Vec<&'a dyn Lock>) {
@@ -342,19 +342,12 @@ unsafe impl<A: OwnedLockable, B: OwnedLockable, C: OwnedLockable, D: OwnedLockab
 {
 }
 
-unsafe impl<
-		'a,
-		A: OwnedLockable,
-		B: OwnedLockable,
-		C: OwnedLockable,
-		D: OwnedLockable,
-		E: OwnedLockable,
-	> OwnedLockable for (A, B, C, D, E)
+unsafe impl<A: OwnedLockable, B: OwnedLockable, C: OwnedLockable, D: OwnedLockable, E: OwnedLockable>
+	OwnedLockable for (A, B, C, D, E)
 {
 }
 
 unsafe impl<
-		'a,
 		A: OwnedLockable,
 		B: OwnedLockable,
 		C: OwnedLockable,
@@ -366,7 +359,6 @@ unsafe impl<
 }
 
 unsafe impl<
-		'a,
 		A: OwnedLockable,
 		B: OwnedLockable,
 		C: OwnedLockable,
diff --git a/src/rwlock/read_lock.rs b/src/rwlock/read_lock.rs
index 011bd8c..29042b5 100644
--- a/src/rwlock/read_lock.rs
+++ b/src/rwlock/read_lock.rs
@@ -6,7 +6,7 @@ use crate::key::Keyable;
 
 use super::{ReadLock, RwLock, RwLockReadGuard, RwLockReadRef};
 
-impl<T: ?Sized + Debug, R: RawRwLock> Debug for ReadLock<T, R> {
+impl<'l, T: ?Sized + Debug, R: RawRwLock> Debug for ReadLock<'l, T, R> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		// safety: this is just a try lock, and the value is dropped
 		//         immediately after, so there's no risk of blocking ourselves
@@ -34,7 +34,7 @@ impl<'l, T, R> From<&'l RwLock<T, R>> for ReadLock<'l, T, R> {
 	}
 }
 
-impl<T: ?Sized, R> AsRef<RwLock<T, R>> for ReadLock<T, R> {
+impl<'l, T: ?Sized, R> AsRef<RwLock<T, R>> for ReadLock<'l, T, R> {
 	fn as_ref(&self) -> &RwLock<T, R> {
 		&self.0
 	}
diff --git a/src/rwlock/write_lock.rs b/src/rwlock/write_lock.rs
index 1f7112a..8501cd8 100644
--- a/src/rwlock/write_lock.rs
+++ b/src/rwlock/write_lock.rs
@@ -6,7 +6,7 @@ use crate::key::Keyable;
 
 use super::{RwLock, RwLockWriteGuard, RwLockWriteRef, WriteLock};
 
-impl<T: ?Sized + Debug, R: RawRwLock> Debug for WriteLock<T, R> {
+impl<'l, T: ?Sized + Debug, R: RawRwLock> Debug for WriteLock<'l, T, R> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		// safety: this is just a try lock, and the value is dropped
 		//         immediately after, so there's no risk of blocking ourselves
@@ -34,9 +34,9 @@ impl<'l, T, R> From<&'l RwLock<T, R>> for WriteLock<'l, T, R> {
 	}
 }
 
-impl<T: ?Sized, R> AsRef<RwLock<T, R>> for WriteLock<T, R> {
+impl<'l, T: ?Sized, R> AsRef<RwLock<T, R>> for WriteLock<'l, T, R> {
 	fn as_ref(&self) -> &RwLock<T, R> {
-		&self.0
+		self.0
 	}
 }
 
@@ -57,7 +57,7 @@ impl<'l, T, R> WriteLock<'l, T, R> {
 	}
 }
 
-impl<T: ?Sized, R: RawRwLock> WriteLock<T, R> {
+impl<'l, T: ?Sized, R: RawRwLock> WriteLock<'l, T, R> {
 	/// Locks the underlying [`RwLock`] with exclusive write access, blocking
 	/// the current until it can be acquired.
 	pub fn lock<'s, 'key: 's, Key: Keyable + 'key>(
-- 
cgit v1.2.3