Add some missing sections to the types chapter

Author: matthewjasper

src/types.md

@@ -93,8 +93,8 @@ Tuple types and values are denoted by listing the types or values of their
 elements, respectively, in a parenthesized, comma-separated list.
 
 Because tuple elements don't have a name, they can only be accessed by
-pattern-matching or by using `N` directly as a field to access the
-`N`th element.
+pattern-matching or by using `N` directly as a field to access the `N`th
+element.
 
 An example of a tuple type and its use:
 
@@ -162,13 +162,13 @@ expression](expressions.html#struct-expressions).
 
 The memory layout of a `struct` is undefined by default to allow for compiler
 optimizations like field reordering, but it can be fixed with the
-`#[repr(...)]` attribute. In either case, fields may be given in any order in
-a corresponding struct *expression*; the resulting `struct` value will always
+`#[repr(...)]` attribute. In either case, fields may be given in any order in a
+corresponding struct *expression*; the resulting `struct` value will always
 have the same memory layout.
 
 The fields of a `struct` may be qualified by [visibility
-modifiers](visibility-and-privacy.html), to allow access to data in a
-struct outside a module.
+modifiers](visibility-and-privacy.html), to allow access to data in a struct
+outside a module.
 
 A _tuple struct_ type is just like a struct type, except that the fields are
 anonymous.
@@ -178,9 +178,6 @@ The one value constructed by the associated [struct
 expression](expressions.html#struct-expressions) is the only value that
 inhabits such a type.
 
-[^structtype]: `struct` types are analogous to `struct` types in C, the
-    *record* types of the ML family, or the *struct* types of the Lisp family.
-
 [^structtype]: `struct` types are analogous to `struct` types in C, the
     *record* types of the ML family, or the *struct* types of the Lisp family.
 
@@ -202,6 +199,21 @@ corresponding `enum` type, as well as the size needed to store a discriminant.
 Enum types cannot be denoted *structurally* as types, but must be denoted by
 named reference to an [`enum` item](items.html#enumerations).
 
+[^enumtype]: The `enum` type is analogous to a `data` constructor declaration in
+             ML, or a *pick ADT* in Limbo.
+
+## Union types
+
+A *union type* is a nominal, heterogeneous C-like union, denoted by the name of
+a [`union` item](items.html#unions).
+
+A union contains the value of any one of its fields. Since the accessing the
+wrong field can cause unexpected or undefined behaviour, it requires `unsafe`,
+except for initializing a union and writing `Copy` fields.
+
+The memory layout of a `union` is undefined by default, but the `#[repr(...)]`
+attribute can be used to fix a layout.
+
 [^enumtype]: The `enum` type is analogous to a `data` constructor declaration in
              ML, or a *pick ADT* in Limbo.
 
@@ -252,6 +264,12 @@ operation: it involves only copying the pointer itself, that is, pointers are
 referencing of a [temporary value](expressions.html#temporary-lifetimes) will
 keep it alive during the scope of the reference itself.
 
+### Mutable references (`&mut`)
+
+These also point to memory owned by some other value. A mutable reference type
+is written `&mut type` or `&'a mut type`. A mutable reference (that hasn't been
+borrowed) is the only way to access the value it points to, so is not `Copy`.
+
 ### Raw pointers (`*const` and `*mut`)
 
 Raw pointers are pointers without safety or liveness guarantees. Raw pointers
@@ -368,9 +386,9 @@ more of the closure traits:
     moved in the body of the closure. `Fn` inherits from `FnMut`, which itself
     inherits from `FnOnce`.
 
-Closures that don't use anything from their environment ("non capturing closures")
-can be coerced to function pointers (`fn`) with the matching signature.
-To adopt the example from the section above:
+Closures that don't use anything from their environment ("non capturing
+closures") can be coerced to function pointers (`fn`) with the matching
+signature. To adopt the example from the section above:
 
 ```rust
 let add = |x, y| x + y;
@@ -385,9 +403,9 @@ x = bo(5,7);
 ## Trait objects
 
 In Rust, trait names also refer to [dynamically sized types] called _trait
-objects_. Like all DSTs, trait objects are used behind some kind of pointer:
-`&SomeTrait` or `Box<SomeTrait>`. Each instance of a pointer to a trait object
-includes:
+objects_. Like all <abbr title="dynamically sized types">DSTs</abbr>, trait
+objects are used behind some kind of pointer: `&SomeTrait` or `Box<SomeTrait>`.
+Each instance of a pointer to a trait object includes:
 
  - a pointer to an instance of a type `T` that implements `SomeTrait`
  - a _virtual method table_, often just called a _vtable_, which contains, for
@@ -490,6 +508,58 @@ objects of type `Ref<'a, SomeTrait>` are the same as `Ref<'a, (SomeTrait +
 example in `std::rc::Rc<T>`.
 
 
+## Dynamically sized types
+
+Most types have a fixed size that is known at compile time and implement the
+trait [`Sized`][sized] A type with a size that is known only at run-time is called a
+_dynamically sized type_ (_DST_) or unsized type. [Slices] and [trait objects]
+are two examples of <abbr title="dynamically sized types">DSTs</abbr>. Such
+types can only be used in certain cases:
+
+* [Pointer types] to <abbr title="dynamically sized types">DSTs</abbr> are
+  sized but have twice the size of pointers to sized types
+    * Pointers to slices also store the number of elements of the slice.
+    * Pointers to trait objects also store a pointer to a vtable.
+* <abbr title="dynamically sized types">DSTs</abbr> can be used as type
+  parameters with a bound of `?Sized`
+* Traits may be implemented for <abbr title="dynamically sized
+  types">DSTs</abbr>. Unlike [elsewhere][sized] `Self: ?Sized` by default in trait
+  definitions.
+* Structs may contain a <abbr title="dynamically sized type">DST</abbr> as the
+  last field, this makes the struct itself a
+  <abbr title="dynamically sized type">DST</abbr>.
+
+Notably: [variables], function parameters, [const] and [static] items must be
+sized.
+
+[sized]: the-sized-trait.html
+[Slices]: #array-and-slice-types
+[trait objects]: #trait-objects
+[Pointer types]: #pointer-types
+[variables]: variables.html
+[const]: items.html#constant-items
+[static]: items.html#static-items
+
+## Interior mutability
+
+References prevent a value being both aliased and mutated: mutable references
+don't allow a value to be aliased and shared references prevent a value from
+being mutated. Sometimes this is too restrictive. The type
+[`std::cell::UnsafeCell<T>`](../std/cell/struct.UnsafeCell.html) provides an
+unsafe API that allows a type to own a `T` that can be mutated through a shared
+reference to the `UnsafeCell`. It is undefined behavior to have multiple `&mut
+UnsafeCell<T>` aliases.
+
+The standard library provides a variety of different types that safely wrap
+this functionality. For example [`std::cell::RefCell<T>`] uses run-time borrow
+checks to ensure the usual rules around multiple references. The
+[`std::sync::atomic`] module contains types that wrap a value that is only
+accessed with atomic operations, allowing the value to be shared and mutated
+across threads.
+
+[`std::cell::RefCell<T>`]: ../std/cell/struct.RefCell.html
+[`std::sync::atomic`]: ../std/sync/atomic.html
+
 ## Type parameters
 
 Within the body of an item that has type parameter declarations, the names of