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;
@@ -490,6 +508,50 @@ 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`]. 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 of the most DSTs. Such types can only be used in certain cases:
+
+* [Pointer types] to DSTs 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.
+* Traits may be implemented for DSTs, this means that `Self` is not assumed to
+  implement `Sized` in trait definitions by default.
+* DSTs can be used as type parameters with a bound of `?Sized`
+* Structs may contain a DST as the last field, this makes the struct a DST as
+  well.
+
+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` (there is no change to mutable references).
+
+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.
+
 ## Type parameters
 
 Within the body of an item that has type parameter declarations, the names of