fix errors

6 files changed, 20 insertions, 20 deletions

diff --git a/src/key.rs b/src/key.rs
index 1cfa209..875f4be 100644
--- a/src/key.rs
+++ b/src/key.rs
@@ -20,7 +20,7 @@ static KEY: Lazy<ThreadLocal<AtomicLock>> = Lazy::new(ThreadLocal::new);
 /// The key for the current thread.
 ///
 /// Only one of these exist per thread. To get the current thread's key, call
-/// [`ThreadKey::get`]. If the `ThreadKey` is dropped, it can be reobtained.
+/// [`ThreadKey::get`]. If the `ThreadKey` is dropped, it can be re-obtained.
 pub struct ThreadKey {
 	phantom: PhantomData<*const ()>, // implement !Send and !Sync
 }
diff --git a/src/lib.rs b/src/lib.rs
index 92b31a0..7e7930f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -22,10 +22,10 @@
 //! 4. **partial allocation**
 //!
 //! This library seeks to solve **partial allocation** by requiring total
-//! allocation. All of the resources a thread needs must be allocated at the
-//! same time. In order to request new resources, the old resources must be
-//! dropped first. Requesting multiple resources at once is atomic. You either
-//! get all of the requested resources or none at all.
+//! allocation. All the resources a thread needs must be allocated at the same
+//! time. In order to request new resources, the old resources must be dropped
+//! first. Requesting multiple resources at once is atomic. You either get all
+//! the requested resources or none at all.
 //!
 //! # Performance
 //!
diff --git a/src/rwlock.rs b/src/rwlock.rs
index 40c5a6e..8f1ba8f 100644
--- a/src/rwlock.rs
+++ b/src/rwlock.rs
@@ -22,7 +22,7 @@ pub type ParkingRwLock<T> = RwLock<T, parking_lot::RawRwLock>;
 /// A reader-writer lock
 ///
 /// This type of lock allows a number of readers or at most one writer at any
-/// point in time. The write portion of thislock typically allows modification
+/// point in time. The write portion of this lock typically allows modification
 /// of the underlying data (exclusive access) and the read portion of this lock
 /// typically allows for read-only access (shared access).
 ///
@@ -57,7 +57,7 @@ pub struct RwLock<T: ?Sized, R> {
 ///
 /// [`LockCollection`]: `crate::LockCollection`
 #[repr(transparent)]
-pub struct ReadLock<T: ?Sized, R>(RwLock<T, R>);
+pub struct ReadLock<'l, T: ?Sized, R>(&'l RwLock<T, R>);
 
 /// Grants write access to an [`RwLock`]
 ///
@@ -66,7 +66,7 @@ pub struct ReadLock<T: ?Sized, R>(RwLock<T, R>);
 ///
 /// [`LockCollection`]: `crate::LockCollection`
 #[repr(transparent)]
-pub struct WriteLock<T: ?Sized, R>(RwLock<T, R>);
+pub struct WriteLock<'l, T: ?Sized, R>(&'l RwLock<T, R>);
 
 /// RAII structure that unlocks the shared read access to a [`RwLock`]
 pub struct RwLockReadRef<'a, T: ?Sized, R: RawRwLock>(
diff --git a/src/rwlock/read_lock.rs b/src/rwlock/read_lock.rs
index a8bb9be..011bd8c 100644
--- a/src/rwlock/read_lock.rs
+++ b/src/rwlock/read_lock.rs
@@ -28,8 +28,8 @@ impl<T: ?Sized + Debug, R: RawRwLock> Debug for ReadLock<T, R> {
 	}
 }
 
-impl<T, R> From<RwLock<T, R>> for ReadLock<T, R> {
-	fn from(value: RwLock<T, R>) -> Self {
+impl<'l, T, R> From<&'l RwLock<T, R>> for ReadLock<'l, T, R> {
+	fn from(value: &'l RwLock<T, R>) -> Self {
 		Self::new(value)
 	}
 }
@@ -40,7 +40,7 @@ impl<T: ?Sized, R> AsRef<RwLock<T, R>> for ReadLock<T, R> {
 	}
 }
 
-impl<T, R> ReadLock<T, R> {
+impl<'l, T, R> ReadLock<'l, T, R> {
 	/// Creates a new `ReadLock` which accesses the given [`RwLock`]
 	///
 	/// # Examples
@@ -52,12 +52,12 @@ impl<T, R> ReadLock<T, R> {
 	/// let read_lock = ReadLock::new(&lock);
 	/// ```
 	#[must_use]
-	pub const fn new(rwlock: RwLock<T, R>) -> Self {
+	pub const fn new(rwlock: &'l RwLock<T, R>) -> Self {
 		Self(rwlock)
 	}
 }
 
-impl<T: ?Sized, R: RawRwLock> ReadLock<T, R> {
+impl<'l, T: ?Sized, R: RawRwLock> ReadLock<'l, T, R> {
 	/// Locks the underlying [`RwLock`] with shared read access, blocking the
 	/// current thread until it can be acquired.
 	pub fn lock<'s, 'key: 's, Key: Keyable + 'key>(
@@ -82,7 +82,7 @@ impl<T: ?Sized, R: RawRwLock> ReadLock<T, R> {
 		self.0.try_read_no_key()
 	}
 
-	/// Immediately drops the guard, and consequentlyreleases the shared lock
+	/// Immediately drops the guard, and consequently releases the shared lock
 	/// on the underlying [`RwLock`].
 	pub fn unlock<'key, Key: Keyable + 'key>(guard: RwLockReadGuard<'_, 'key, T, Key, R>) -> Key {
 		RwLock::unlock_read(guard)
diff --git a/src/rwlock/rwlock.rs b/src/rwlock/rwlock.rs
index d16befe..7070b0e 100644
--- a/src/rwlock/rwlock.rs
+++ b/src/rwlock/rwlock.rs
@@ -254,7 +254,7 @@ impl<T: ?Sized, R: RawRwLock> RwLock<T, R> {
 	/// Attempts to lock this `RwLock` with exclusive write access.
 	///
 	/// This function does not block. If the lock could not be acquired at this
-	/// time, then `None` is returned. Otherwise an RAII guard is returned
+	/// time, then `None` is returned. Otherwise, an RAII guard is returned
 	/// which will release the lock when it is dropped.
 	///
 	/// This function does not provide any guarantees with respect to the
diff --git a/src/rwlock/write_lock.rs b/src/rwlock/write_lock.rs
index a344125..1f7112a 100644
--- a/src/rwlock/write_lock.rs
+++ b/src/rwlock/write_lock.rs
@@ -21,15 +21,15 @@ impl<T: ?Sized + Debug, R: RawRwLock> Debug for WriteLock<T, R> {
 				}
 			}
 
-			f.debug_struct("ReadLock")
+			f.debug_struct("WriteLock")
 				.field("data", &LockedPlaceholder)
 				.finish()
 		}
 	}
 }
 
-impl<T, R> From<RwLock<T, R>> for WriteLock<T, R> {
-	fn from(value: RwLock<T, R>) -> Self {
+impl<'l, T, R> From<&'l RwLock<T, R>> for WriteLock<'l, T, R> {
+	fn from(value: &'l RwLock<T, R>) -> Self {
 		Self::new(value)
 	}
 }
@@ -40,7 +40,7 @@ impl<T: ?Sized, R> AsRef<RwLock<T, R>> for WriteLock<T, R> {
 	}
 }
 
-impl<T, R> WriteLock<T, R> {
+impl<'l, T, R> WriteLock<'l, T, R> {
 	/// Creates a new `WriteLock` which accesses the given [`RwLock`]
 	///
 	/// # Examples
@@ -52,7 +52,7 @@ impl<T, R> WriteLock<T, R> {
 	/// let write_lock = WriteLock::new(&lock);
 	/// ```
 	#[must_use]
-	pub const fn new(rwlock: RwLock<T, R>) -> Self {
+	pub const fn new(rwlock: &'l RwLock<T, R>) -> Self {
 		Self(rwlock)
 	}
 }