Changes from review

Author: simonsan

functional/stateful-types.md

@@ -6,13 +6,13 @@ Rust's functional roots allow for it to be more expressive in the type system
 than many other languages, and turn many kinds of programming problems into
 "static typing" problems. A key part of this idea is the way generic types work.
 
-In C++ and Java, for example, generic types a meta-programming construct for the
-compiler. A `Vec<int>` and `Vec<char>` in C++ are just two different copies of
+In C++ and Java, for example, generic types are a meta-programming construct for
+the compiler. `Vec<int>` and `Vec<char>` in C++ are just two different copies of
 the same boilerplate code for a `Vec` type, with two different types filled in.
 
 In Rust, the generic type parameter creates what is known as a "type class
 constraint", and each value used by an end user *actually changes the type of
-each instatiation*.  In other words, `Vec<usize>` and `Vec<char>` *are two
+each instatiation*. In other words, `Vec<usize>` and `Vec<char>` *are two
 different types*.
 
 This is why `impl` blocks must specify generic parameters: different ones can
@@ -102,9 +102,9 @@ fn main() {
 Why those chances to panic? Because there are *state invariants* here:
 
 1. `set_param` can only be called in an "initial" state.
-1. `init` must be called before any scripts are compiled.
-1. `exec` can only be called in a "loaded" or "ready" state.
-1. `init` must be called *exactly once*.
+2. `init` must be called before any scripts are compiled.
+3. `exec` can only be called in a "loaded" or "ready" state.
+4. `init` must be called *exactly once*.
 
 It would be possible to add these to the `Error` types instead of panicking.
 However, this solution is suboptimal. Not only would users of the code
@@ -117,7 +117,9 @@ if it were misused. After all, every user's program contains the invalid call
 order in the logic itself.
 
 In Rust, this is actually possible! The solution is to *change the type* in
-order to enforce the invariants. How? With a private generic parameter.
+order to enforce the invariants.
+
+How? With a private generic parameter.
 
 Here is what that looks like:
 
@@ -227,7 +229,7 @@ fn main() {
 ```
 
 They would get a syntax error. The type `Interpreter<Loaded>` does not
-implement set param, only the type `Interpreter<Init>` does.
+implement `set_param()`, only the type `Interpreter<Init>` does.
 
 ## Disadvantages
 
@@ -236,7 +238,7 @@ transitions, an `InvalidState` enum value in an error type might be simpler.
 
 ## Alternatives
 
-There are a number of simpler state machines, however, that have their own patterns:
+There are a number of simpler state machines that have their own patterns:
 
 1. If the state transition is during construction/finalizing of an object, see
 [Builder Pattern](../patterns/creational/builder.md).