OnceCell & OnceLock docs: Using set/empty consistently

Author: Pyr0de

library/core/src/cell/once.rs

@@ -6,7 +6,7 @@ use crate::{fmt, mem};
 /// This allows obtaining a shared `&T` reference to its inner value without copying or replacing
 /// it (unlike [`Cell`]), and without runtime borrow checks (unlike [`RefCell`]). However,
 /// only immutable references can be obtained unless one has a mutable reference to the cell
-/// itself. In the same vein, the cell can only be re-initialized with such a mutable reference.
+/// itself. In the same vein, the cell can only be re-set with such a mutable reference.
 ///
 /// For a thread-safe version of this struct, see [`std::sync::OnceLock`].
 ///
@@ -68,7 +68,7 @@ impl<T> OnceCell<T> {
     /// # Errors
     ///
     /// This method returns `Ok(())` if the cell was empty and `Err(value)` if
-    /// it was full.
+    /// it was set.
     ///
     /// # Examples
     ///
@@ -98,7 +98,7 @@ impl<T> OnceCell<T> {
     /// # Errors
     ///
     /// This method returns `Ok(&value)` if the cell was empty and
-    /// `Err(&current_value, value)` if it was full.
+    /// `Err(&current_value, value)` if it was set.
     ///
     /// # Examples
     ///
@@ -130,15 +130,15 @@ impl<T> OnceCell<T> {
         Ok(slot.insert(value))
     }
 
-    /// Gets the contents of the cell, initializing it with `f`
+    /// Gets the contents of the cell, setting it with `f`
     /// if the cell was empty.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
-    /// It is an error to reentrantly initialize the cell from `f`. Doing
+    /// It is an error to reentrantly set the cell from `f`. Doing
     /// so results in a panic.
     ///
     /// # Examples
@@ -164,12 +164,12 @@ impl<T> OnceCell<T> {
     }
 
     /// Gets the mutable reference of the contents of the cell,
-    /// initializing it with `f` if the cell was empty.
+    /// setting it with `f` if the cell was empty.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
     /// # Examples
     ///
@@ -199,16 +199,16 @@ impl<T> OnceCell<T> {
         }
     }
 
-    /// Gets the contents of the cell, initializing it with `f` if
+    /// Gets the contents of the cell, setting it with `f` if
     /// the cell was empty. If the cell was empty and `f` failed, an
     /// error is returned.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
-    /// It is an error to reentrantly initialize the cell from `f`. Doing
+    /// It is an error to reentrantly set the cell from `f`. Doing
     /// so results in a panic.
     ///
     /// # Examples
@@ -238,14 +238,14 @@ impl<T> OnceCell<T> {
         self.try_init(f)
     }
 
-    /// Gets the mutable reference of the contents of the cell, initializing
+    /// Gets the mutable reference of the contents of the cell, setting
     /// it with `f` if the cell was empty. If the cell was empty and `f` failed,
     /// an error is returned.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
     /// # Examples
     ///
@@ -256,7 +256,7 @@ impl<T> OnceCell<T> {
     ///
     /// let mut cell: OnceCell<u32> = OnceCell::new();
     ///
-    /// // Failed initializers do not change the value
+    /// // Failed sets do not change the value
     /// assert!(cell.get_mut_or_try_init(|| "not a number!".parse()).is_err());
     /// assert!(cell.get().is_none());
     ///
@@ -319,9 +319,9 @@ impl<T> OnceCell<T> {
         self.inner.into_inner()
     }
 
-    /// Takes the value out of this `OnceCell`, moving it back to an uninitialized state.
+    /// Takes the value out of this `OnceCell`, moving it back to an empty state.
     ///
-    /// Has no effect and returns `None` if the `OnceCell` hasn't been initialized.
+    /// Has no effect and returns `None` if the `OnceCell` hasn't been set.
     ///
     /// Safety is guaranteed by requiring a mutable reference.
     ///

library/std/src/sync/once_lock.rs

@@ -141,7 +141,7 @@ impl<T> OnceLock<T> {
 
     /// Gets the reference to the underlying value.
     ///
-    /// Returns `None` if the cell is empty, or being initialized. This
+    /// Returns `None` if the cell is empty, or being set. This
     /// method never blocks.
     #[inline]
     #[stable(feature = "once_cell", since = "1.70.0")]
@@ -168,7 +168,7 @@ impl<T> OnceLock<T> {
         }
     }
 
-    /// Blocks the current thread until the cell is initialized.
+    /// Blocks the current thread until the cell is set.
     ///
     /// # Example
     ///
@@ -198,8 +198,8 @@ impl<T> OnceLock<T> {
 
     /// Sets the contents of this cell to `value`.
     ///
-    /// May block if another thread is currently attempting to initialize the cell. The cell is
-    /// guaranteed to contain a value when set returns, though not necessarily the one provided.
+    /// May block if another thread is currently attempting to set the cell. The cell is
+    /// guaranteed to contain a value when `set` returns, though not necessarily the one provided.
     ///
     /// Returns `Ok(())` if the cell's value was set by this call.
     ///
@@ -233,10 +233,10 @@ impl<T> OnceLock<T> {
     /// Sets the contents of this cell to `value` if the cell was empty, then
     /// returns a reference to it.
     ///
-    /// May block if another thread is currently attempting to initialize the cell. The cell is
-    /// guaranteed to contain a value when set returns, though not necessarily the one provided.
+    /// May block if another thread is currently attempting to set the cell. The cell is
+    /// guaranteed to contain a value when `set` returns, though not necessarily the one provided.
     ///
-    /// Returns `Ok(&value)` if the cell was empty and `Err(&current_value, value)` if it was full.
+    /// Returns `Ok(&value)` if the cell was empty and `Err(&current_value, value)` if it was set.
     ///
     /// # Examples
     ///
@@ -269,19 +269,19 @@ impl<T> OnceLock<T> {
         }
     }
 
-    /// Gets the contents of the cell, initializing it with `f` if the cell
+    /// Gets the contents of the cell, setting it with `f` if the cell
     /// was empty.
     ///
     /// Many threads may call `get_or_init` concurrently with different
-    /// initializing functions, but it is guaranteed that only one function
+    /// setting functions, but it is guaranteed that only one function
     /// will be executed.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
-    /// It is an error to reentrantly initialize the cell from `f`. The
+    /// It is an error to reentrantly set the cell from `f`. The
     /// exact outcome is unspecified. Current implementation deadlocks, but
     /// this may be changed to a panic in the future.
     ///
@@ -307,15 +307,15 @@ impl<T> OnceLock<T> {
         }
     }
 
-    /// Gets the mutable reference of the contents of the cell, initializing
+    /// Gets the mutable reference of the contents of the cell, setting
     /// it with `f` if the cell was empty.
     ///
     /// This method never blocks.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and the cell
-    /// remains uninitialized.
+    /// remains empty.
     ///
     /// # Examples
     ///
@@ -345,16 +345,16 @@ impl<T> OnceLock<T> {
         }
     }
 
-    /// Gets the contents of the cell, initializing it with `f` if
+    /// Gets the contents of the cell, setting it with `f` if
     /// the cell was empty. If the cell was empty and `f` failed, an
     /// error is returned.
     ///
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and
-    /// the cell remains uninitialized.
+    /// the cell remains empty.
     ///
-    /// It is an error to reentrantly initialize the cell from `f`.
+    /// It is an error to reentrantly set the cell from `f`.
     /// The exact outcome is unspecified. Current implementation
     /// deadlocks, but this may be changed to a panic in the future.
     ///
@@ -396,7 +396,7 @@ impl<T> OnceLock<T> {
         Ok(unsafe { self.get_unchecked() })
     }
 
-    /// Gets the mutable reference of the contents of the cell, initializing
+    /// Gets the mutable reference of the contents of the cell, setting
     /// it with `f` if the cell was empty. If the cell was empty and `f` failed,
     /// an error is returned.
     ///
@@ -405,7 +405,7 @@ impl<T> OnceLock<T> {
     /// # Panics
     ///
     /// If `f` panics, the panic is propagated to the caller, and
-    /// the cell remains uninitialized.
+    /// the cell remains empty.
     ///
     /// # Examples
     ///
@@ -416,7 +416,7 @@ impl<T> OnceLock<T> {
     ///
     /// let mut cell: OnceLock<u32> = OnceLock::new();
     ///
-    /// // Failed initializers do not change the value
+    /// // Failed sets do not change the value
     /// assert!(cell.get_mut_or_try_init(|| "not a number!".parse()).is_err());
     /// assert!(cell.get().is_none());
     ///
@@ -460,9 +460,9 @@ impl<T> OnceLock<T> {
         self.take()
     }
 
-    /// Takes the value out of this `OnceLock`, moving it back to an uninitialized state.
+    /// Takes the value out of this `OnceLock`, moving it back to an empty state.
     ///
-    /// Has no effect and returns `None` if the `OnceLock` hasn't been initialized.
+    /// Has no effect and returns `None` if the `OnceLock` hasn't been set.
     ///
     /// Safety is guaranteed by requiring a mutable reference.
     ///
@@ -528,7 +528,7 @@ impl<T> OnceLock<T> {
 
     /// # Safety
     ///
-    /// The value must be initialized
+    /// The value must be set
     #[inline]
     unsafe fn get_unchecked(&self) -> &T {
         debug_assert!(self.is_initialized());
@@ -537,7 +537,7 @@ impl<T> OnceLock<T> {
 
     /// # Safety
     ///
-    /// The value must be initialized
+    /// The value must be set
     #[inline]
     unsafe fn get_unchecked_mut(&mut self) -> &mut T {
         debug_assert!(self.is_initialized());