Add convenience const constructors to parking_lot

This adds various helper functions to `parking_lot` that allow creating
parking_lot's mutexes, reentrant mutexes, fair mutexes and RwLocks in
constant contexts on stable Rust.

Author: CryZe

src/fair_mutex.rs

@@ -80,6 +80,12 @@ 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> {
+    FairMutex::const_new(<RawFairMutex as lock_api::RawMutex>::INIT, val)
+}
+
 /// An RAII implementation of a "scoped lock" of a mutex. When this structure is
 /// dropped (falls out of scope), the lock will be unlocked.
 ///

src/lib.rs

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

src/mutex.rs

@@ -86,6 +86,12 @@ 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> {
+    Mutex::const_new(<RawMutex as lock_api::RawMutex>::INIT, val)
+}
+
 /// An RAII implementation of a "scoped lock" of a mutex. When this structure is
 /// dropped (falls out of scope), the lock will be unlocked.
 ///

src/remutex.rs

@@ -40,6 +40,16 @@ 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> {
+    ReentrantMutex::const_new(
+        <RawMutex as lock_api::RawMutex>::INIT,
+        <RawThreadId as lock_api::GetThreadId>::INIT,
+        val,
+    )
+}
+
 /// An RAII implementation of a "scoped lock" of a reentrant mutex. When this structure
 /// is dropped (falls out of scope), the lock will be unlocked.
 ///

src/rwlock.rs

@@ -88,6 +88,12 @@ 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> {
+    RwLock::const_new(<RawRwLock as lock_api::RawRwLock>::INIT, val)
+}
+
 /// RAII structure used to release the shared read access of a lock when
 /// dropped.
 pub type RwLockReadGuard<'a, T> = lock_api::RwLockReadGuard<'a, RawRwLock, T>;