Start converting Vec example to stable Rust - use NonNull instead of Unique

Author: blkerby

src/vec-layout.md

@@ -29,66 +29,24 @@ so we'd like to not use it if possible, though.
 
 As a recap, Unique is a wrapper around a raw pointer that declares that:
 
-* We are variant over `T`
+* We are covariant over `T`
 * We may own a value of type `T` (for drop check)
 * We are Send/Sync if `T` is Send/Sync
 * Our pointer is never null (so `Option<Vec<T>>` is null-pointer-optimized)
 
-We can implement all of the above requirements except for the last
-one in stable Rust:
+We can implement all of the above requirements in stable Rust. To do this, instead of using `Unique<T>` we will use [`NonNull<T>`](https://doc.rust-lang.org/stable/std/ptr/struct.NonNull.html), another wrapper around a raw pointer, which gives us two of the above properties, namely it is covariant over `T` and is declared to never be null. By
+adding a `PhantomData<T>` (for drop check) and implementing Send/Sync if `T` is, we then get the same results as if we had used `Unique<T>`:
 
 ```rust
-use std::marker::PhantomData;
-use std::ops::Deref;
-use std::mem;
-
-struct Unique<T> {
-    ptr: *const T,              // *const for variance
-    _marker: PhantomData<T>,    // For the drop checker
-}
-
-// Deriving Send and Sync is safe because we are the Unique owners
-// of this data. It's like Unique<T> is "just" T.
-unsafe impl<T: Send> Send for Unique<T> {}
-unsafe impl<T: Sync> Sync for Unique<T> {}
-
-impl<T> Unique<T> {
-    pub fn new(ptr: *mut T) -> Self {
-        Unique { ptr: ptr, _marker: PhantomData }
-    }
-
-    pub fn as_ptr(&self) -> *mut T {
-        self.ptr as *mut T
-    }
-}
-
-# fn main() {}
-```
-
-Unfortunately the mechanism for stating that your value is non-zero is
-unstable and unlikely to be stabilized soon. As such we're just going to
-take the hit and use std's Unique:
-
-
-```rust
-#![feature(ptr_internals)]
-
-use std::ptr::{Unique, self};
-
 pub struct Vec<T> {
-    ptr: Unique<T>,
+    ptr: NonNull<T>,
     cap: usize,
     len: usize,
+    _marker: PhantomData<T>,
 }
 
-# fn main() {}
+unsafe impl<T: Send> Send for Vec<T> {}
+unsafe impl<T: Sync> Sync for Vec<T> {}
 ```
 
-If you don't care about the null-pointer optimization, then you can use the
-stable code. However we will be designing the rest of the code around enabling
-this optimization. It should be noted that `Unique::new` is unsafe to call, because
-putting `null` inside of it is Undefined Behavior. Our stable Unique doesn't
-need `new` to be unsafe because it doesn't make any interesting guarantees about
-its contents.
-
 [ownership]: ownership.html