anchor.diff:                  .col-md-6
                       h3 Expressions
                       p.
  -                        An expression is a chunk of code that returns
  -                        a value. An expression can always be assigned to a variable. A
  -                        statement is a chunk of code that does not return a value. A
  -                        statement cannot be assigned to a variable. Most parts of Standard ML
  -                        are expressions, not statements. Expressions consist of one of
  -                        the following:
  +                        An expression is a chunk of code that returns a value. An expression
  +                        can always be assigned to a variable. On the other hand, a statement
  +                        is a chunk of code that does not return a value. A statement cannot be
  +                        assigned to a variable. Most parts of Standard ML are expressions,
  +                        not statements. Expressions consist of one of <the following:
                       ul
                           li Literals (e.g. <code>1</code>, <code>"foo"</code>)
                           li Variable references (e.g. <code>a</code>, <code>theVariable</code>)
                           li Expressions combined by an infix operator (e.g. <code>a + b</code>, <code>1 + theVariable</code>)
  -                        li If / then (e.g. <code>if a then b else c</code>)
  -                        li Case statements (e.g. <code>case a of 2 => true | 3 => false</code>)
  +                        li If blocks (e.g. <code>if a then b else c</code>)
  +                        li Case blocks (e.g. <code>case a of 2 => true | 3 => false</code>)
                           li Lambda functions (e.g. <code>fn a => a</code>)
                           li Function calls (e.g. <code>split "foo" "o"</code>)
                           li Let blocks (e.g. <code>let val i = 1 in i end</code>)
  +                        li Local blocks (e.g. <code>local val i = 1 in i end</code>)
                           li Compound expressions (e.g. <code>1; a + b</code>)
                           li Any expression in parenthesis (e.g. <code>(1)</code>, <code>(theVariable)</code>)
                       p The following are <strong>not</strong> expressions:
  -                        li Function declarations
  +                        li Val declarations (e.g. the <code>val i = 1</code> part of <code>let val i = 1 in i end</code>)
  +                        li Named function declarations (e.g. <code>fun a b => b</code>)
  +                        li Type declarations (e.g. <code>type a = int</code>, <code>datatype b = Int of int | String of string</code>)
  +                        li Structures (declarations and references)
  +                        li Signatures (declarations and references)
  +                        li Functors (declarations and references)
                       h4 Literals
                       p.
                           The following types can be expressed as literal values:
  
positive.code:                         The <code>!</code> operator dereferences the ref cell to get its value.
                          The type of <code>a</code> and <code>b</code> is <code>ref int</code>.
                      p.
                          Arrays also mutable values (as opposed to vectors), but we'll get into
                          those in a later chapter.
                      p
                          a(href="/guides/learn-standardml/functions") Chapter 4. Functions
negative.code:                         li Booleans (e.g. <code>true</code>, <code>false</code>)
                          li Tuples (e.g. <code>(1, 2)</code>, <code>(x, 4.0, (12, 1))</code>)
                          li Lists (e.g. <code>[1, 2]</code>, <code>[(1, 2), (3, 4)]</code>)
                          li Records (e.g. <code>{ foo=1, bar=2.0 }</code>)
                      p.note.
                          Some Standard ML implementations (including MLton, but not Poly/ML)
                          additionally have support for vector literals (e.g. <code>\#[1, 2, 3]</code>)
                          as part of Successor ML, informally agreed upon extensions to the standard.
                      h4 Parenthesis, semi-colons and compound expressions
                      p.
                          Semi-colons are mostly optional, except for in compound expressions.
                          But semi-colons are often necessary to disambiguate the end of a function
                          call. Here is an example:
                      pre
                          code.
  