anchor.diff:                                  foo "bar";
                                   goo "baz"
                               end
  +                    p.note.
  +                        Standard ML officially requires there be no trailing semi-colon in
  +                        a compound expression. Simarily, a comma must not follow the last
  +                        element in a tuple, list, or record. Some Standard ML implementations
  +                        (including MLton, but not Poly/ML) relax this requirement as part of
  +                        Successor ML.
                       p.
                           The <code>in ... end</code> block actually takes a single expression. But compound
                           expressions are expressions too and provide a way to evaluate multiple
  -                        expressions for side-effects while only returning the last.
  +                        expressions for side-effects while only returning the value of the last
  +                        expression.
                       p.
                           Parenthesis are typically allowed anywhere, surrounding an expression.
                           But outside of the <code>in ... end</code> block of a let block, you will need to
  
positive.code:                 .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:
                      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 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 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
                      h4 Literals
                      p.
                          The following types can be expressed as literal values:
  
negative.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 are 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