documentation fixes

Author: Pointerbender

Cargo.toml

@@ -1,18 +1,18 @@
 #cargo-features = ["rust-version"]
 
 [package]
-name = "deferred_reference"
-version = "0.1.0"
+name = "deferred-reference"
+version = "0.1.1"
 authors = ["Pointerbender"]
 #rust-version = "1.51.0"
 edition = "2018"
 license = "MIT"
 description = "A deferred reference is not an actual reference, it is merely a smart pointer tied to the lifetime of the location it points to."
-keywords = ["deferred", "reference", "pointer", "lifetime", "unsafecell"]
+keywords = ["deferred", "reference", "pointer", "lifetime", "borrow"]
 categories = ["concurrency", "data-structures", "memory-management", "no-std", "rust-patterns"]
-homepage = "https://github.com/Pointerbender/deferred_reference#readme"
-repository = "https://github.com/Pointerbender/deferred_reference"
-documentation = "https://docs.rs/deferred_reference"
+homepage = "https://github.com/Pointerbender/deferred-reference#readme"
+repository = "https://github.com/Pointerbender/deferred-reference"
+documentation = "https://docs.rs/deferred-reference"
 readme = "README.md"
 
 [features]

README.md

@@ -20,18 +20,18 @@ If you're on nightly Rust, add the following dependency to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-deferred_reference = { version = "0.1.0" }
+deferred-reference = { version = "0.1.1" }
 ```
 
 This crate uses some unstable features, but it also works on stable Rust with less features.
 For using this crate in stable Rust you need to disable the unstable nightly features using the `default-features` flag, like so:
 
 ```toml
 [dependencies]
-deferred_reference = { version = "0.1.0", default-features = false }
+deferred-reference = { version = "0.1.1", default-features = false }
 ```
 
-Please see the [documentation for this crate](https://docs.rs/deferred_reference) on how to get started with some concrete code examples.
+Please see the [documentation for this crate](https://docs.rs/deferred-reference) on how to get started with some concrete code examples.
 
 ## `#![no_std]` environments
 This crate is entirely `#![no_std]` and does not depend on the `alloc` crate. No additional `Cargo.toml` features need to be configured

src/defer_mut.rs

@@ -16,14 +16,17 @@ use super::{Defer, Deferred};
 ///
 /// # Example
 /// ```
-/// #[macro_use] extern crate deferred_reference;
+/// #[macro_use]
+/// extern crate deferred_reference;
 /// use deferred_reference::Deferred;
-/// let mut buffer = [0u8; 1024];
-/// let deferred: Deferred<&mut [u8]> =  unsafe { defer_mut!(buffer) };
-/// assert_eq!(buffer[0], deferred[0]);
-/// // works also for references to arrays:
-/// let deferred: Deferred<&mut [u8; 1024]> =  unsafe { defer_mut!(buffer) };
-/// assert_eq!(buffer[0], deferred[0]);
+/// fn main() {
+///     let mut buffer = [0u8; 1024];
+///     let deferred: Deferred<&mut [u8]> =  unsafe { defer_mut!(buffer) };
+///     assert_eq!(buffer[0], deferred[0]);
+///     // works also for references to arrays:
+///     let deferred: Deferred<&mut [u8; 1024]> =  unsafe { defer_mut!(buffer) };
+///     assert_eq!(buffer[0], deferred[0]);
+/// }
 /// ```
 ///
 /// # Safety
@@ -42,14 +45,17 @@ use super::{Defer, Deferred};
 ///
 /// Here is an example that will trigger undefined behavior, in order to illustrate how unsafe this macro is:
 /// ```no_run
-/// #[macro_use] extern crate deferred_reference;
-/// let mut buffer = [0u8; 1024];
-/// let deferred = unsafe { defer_mut!(buffer) };
-/// buffer[0] = 42; // this implicitly creates a temporary mutable reference to all of `buffer`
-/// // `deferred` is now invalidated !!!
-/// // therefore dereferencing `deferred` is undefined behavior, even though
-/// // the lifetimes of the immutable and mutable references don't overlap:
-/// assert_eq!(buffer[0], deferred[0]); // undefined behavior!!!
+/// #[macro_use]
+/// extern crate deferred_reference;
+/// fn main() {
+///     let mut buffer = [0u8; 1024];
+///     let deferred = unsafe { defer_mut!(buffer) };
+///     buffer[0] = 42; // implicitly creates a temporary mutable reference to all of `buffer`
+///     // `deferred` is now invalidated !!!
+///     // therefore dereferencing `deferred` is undefined behavior, even though
+///     // the lifetimes of the immutable and mutable references don't overlap:
+///     assert_eq!(buffer[0], deferred[0]); // undefined behavior!!!
+/// }
 /// ```
 ///
 /// # Caveat

src/lib.rs

@@ -117,6 +117,7 @@
 //!       period of time).
 
 #![no_std]
+#![doc(html_root_url = "https://docs.rs/deferred-reference/0.1.1")]
 // the `slice_ptr_len` feature is needed for deferred references to slices
 #![cfg_attr(feature = "slice_ptr_len", feature(slice_ptr_len))]
 // experimental: the `coerce_unsized` feature is need to unsize the reference