Address the review comments

This splits the doc comments into multiple paragraphs and renames the
helpers to create the locking primitives to `const_*` instead of
`new_*`.

Author: CryZe

lock_api/src/mutex.rs

@@ -132,8 +132,9 @@ impl<R: RawMutex, T> Mutex<R, T> {
 }
 
 impl<R, T> Mutex<R, T> {
-    /// Creates a new mutex based on a pre-existing raw mutex. This allows
-    /// creating a mutex in a constant context on stable Rust.
+    /// Creates a new mutex based on a pre-existing raw mutex.
+    ///
+    /// This allows creating a mutex in a constant context on stable Rust.
     #[inline]
     pub const fn const_new(raw_mutex: R, val: T) -> Mutex<R, T> {
         Mutex {

lock_api/src/remutex.rs

@@ -198,21 +198,19 @@ impl<R: RawMutex, G: GetThreadId, T> ReentrantMutex<R, G, T> {
 }
 
 impl<R, G, T> ReentrantMutex<R, G, T> {
-    /// Creates a new reentrant mutex based on a pre-existing raw reentrant
-    /// mutex and a helper to get the thread ID. This allows creating a
-    /// reentrant mutex in a constant context on stable Rust.
-    #[inline]
-    pub const fn const_new(
-        raw_reentrant_mutex: R,
-        get_thread_id: G,
-        val: T,
-    ) -> ReentrantMutex<R, G, T> {
+    /// Creates a new reentrant mutex based on a pre-existing raw mutex and a
+    /// helper to get the thread ID.
+    ///
+    /// This allows creating a reentrant mutex in a constant context on stable
+    /// Rust.
+    #[inline]
+    pub const fn const_new(raw_mutex: R, get_thread_id: G, val: T) -> ReentrantMutex<R, G, T> {
         ReentrantMutex {
             data: UnsafeCell::new(val),
             raw: RawReentrantMutex {
                 owner: AtomicUsize::new(0),
                 lock_count: Cell::new(0),
-                mutex: raw_reentrant_mutex,
+                mutex: raw_mutex,
                 get_thread_id,
             },
         }

lock_api/src/rwlock.rs

@@ -299,8 +299,10 @@ impl<R: RawRwLock, T> RwLock<R, T> {
 
 impl<R, T> RwLock<R, T> {
     /// Creates a new new instance of an `RwLock<T>` based on a pre-existing
-    /// `RawRwLock<T>`. This allows creating a `RwLock<T>` in a constant context
-    /// on stable Rust.
+    /// `RawRwLock<T>`.
+    ///
+    /// This allows creating a `RwLock<T>` in a constant context on stable
+    /// Rust.
     #[inline]
     pub const fn const_new(raw_rwlock: R, val: T) -> RwLock<R, T> {
         RwLock {

src/fair_mutex.rs

@@ -80,9 +80,10 @@ use lock_api;
 /// ```
 pub type FairMutex<T> = lock_api::Mutex<RawFairMutex, T>;
 
-/// Creates a new fair mutex in an unlocked state ready for use. This allows
-/// creating a fair mutex in a constant context on stable Rust.
-pub const fn new_fair_mutex<T>(val: T) -> FairMutex<T> {
+/// Creates a new fair mutex in an unlocked state ready for use.
+///
+/// This allows creating a fair mutex in a constant context on stable Rust.
+pub const fn const_fair_mutex<T>(val: T) -> FairMutex<T> {
     FairMutex::const_new(<RawFairMutex as lock_api::RawMutex>::INIT, val)
 }
 

src/lib.rs

@@ -31,18 +31,18 @@ pub mod deadlock;
 mod deadlock;
 
 pub use self::condvar::{Condvar, WaitTimeoutResult};
-pub use self::fair_mutex::{new_fair_mutex, FairMutex, FairMutexGuard, MappedFairMutexGuard};
-pub use self::mutex::{new_mutex, MappedMutexGuard, Mutex, MutexGuard};
+pub use self::fair_mutex::{const_fair_mutex, FairMutex, FairMutexGuard, MappedFairMutexGuard};
+pub use self::mutex::{const_mutex, MappedMutexGuard, Mutex, MutexGuard};
 pub use self::once::{Once, OnceState};
 pub use self::raw_fair_mutex::RawFairMutex;
 pub use self::raw_mutex::RawMutex;
 pub use self::raw_rwlock::RawRwLock;
 pub use self::remutex::{
-    new_reentrant_mutex, MappedReentrantMutexGuard, RawThreadId, ReentrantMutex,
+    const_reentrant_mutex, MappedReentrantMutexGuard, RawThreadId, ReentrantMutex,
     ReentrantMutexGuard,
 };
 pub use self::rwlock::{
-    new_rwlock, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard,
+    const_rwlock, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard,
     RwLockUpgradableReadGuard, RwLockWriteGuard,
 };
 pub use ::lock_api;

src/mutex.rs

@@ -86,9 +86,10 @@ use lock_api;
 /// ```
 pub type Mutex<T> = lock_api::Mutex<RawMutex, T>;
 
-/// Creates a new mutex in an unlocked state ready for use. This allows creating
-/// a mutex in a constant context on stable Rust.
-pub const fn new_mutex<T>(val: T) -> Mutex<T> {
+/// Creates a new mutex in an unlocked state ready for use.
+///
+/// This allows creating a mutex in a constant context on stable Rust.
+pub const fn const_mutex<T>(val: T) -> Mutex<T> {
     Mutex::const_new(<RawMutex as lock_api::RawMutex>::INIT, val)
 }
 

src/remutex.rs

@@ -40,9 +40,10 @@ unsafe impl GetThreadId for RawThreadId {
 /// primitive.
 pub type ReentrantMutex<T> = lock_api::ReentrantMutex<RawMutex, RawThreadId, T>;
 
-/// Creates a new reentrant mutex in an unlocked state ready for use. This
-/// allows creating a reentrant mutex in a constant context on stable Rust.
-pub const fn new_reentrant_mutex<T>(val: T) -> ReentrantMutex<T> {
+/// Creates a new reentrant mutex in an unlocked state ready for use.
+///
+/// This allows creating a reentrant mutex in a constant context on stable Rust.
+pub const fn const_reentrant_mutex<T>(val: T) -> ReentrantMutex<T> {
     ReentrantMutex::const_new(
         <RawMutex as lock_api::RawMutex>::INIT,
         <RawThreadId as lock_api::GetThreadId>::INIT,

src/rwlock.rs

@@ -88,9 +88,10 @@ use lock_api;
 /// ```
 pub type RwLock<T> = lock_api::RwLock<RawRwLock, T>;
 
-/// Creates a new instance of an `RwLock<T>` which is unlocked. This allows
-/// creating a `RwLock<T>` in a constant context on stable Rust.
-pub const fn new_rwlock<T>(val: T) -> RwLock<T> {
+/// Creates a new instance of an `RwLock<T>` which is unlocked.
+///
+/// This allows creating a `RwLock<T>` in a constant context on stable Rust.
+pub const fn const_rwlock<T>(val: T) -> RwLock<T> {
     RwLock::const_new(<RawRwLock as lock_api::RawRwLock>::INIT, val)
 }