Add some missing sections to the types chapter

Author: matthewjasper

src/types.md

@@ -17,7 +17,7 @@ these are called _primitive types_. Some of these are induvidual types:
 * The [machine-dependent integer types].
 * The [textual types] `char` and `str`.
 
-There are also some primitive constructs for generic types built in to the language
+There are also some primitive constructs for generic types built in to the language:
 
 * [Tuples]
 * [Arrays]
@@ -201,6 +201,18 @@ 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.
+
 ## Recursive types
 
 Nominal types — [structs](#struct-types),
@@ -247,6 +259,13 @@ 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
@@ -482,6 +501,48 @@ default bound for trait objects of that type. For example, `std::cell::Ref<'a,
 T>` contains a `T: 'a` bound, therefore trait objects of type `Ref<'a,
 SomeTrait>` are the same as `Ref<'a, (SomeTrait + 'a)>`.
 
+## 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
+* 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` (mutable references still have to be unique).
+
+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