anchor.diff:                          expressions for side-effects while only returning the value of the last
                           expression.
                       p.
  -                        Parenthesis are typically allowed anywhere, surrounding an expression.
  +                        Parentheses are typically allowed anywhere, surrounding an expression.
                           But outside of the <code>in ... end</code> block of a let block, you will need to
  -                        surround a compound expression in parenthesis to disambiguate:
  +                        surround a compound expression in parentheses to disambiguate:
                       pre
                           code.
                               > val i = (1 + 2; 8);
  
positive.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 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>)
  
negative.code:                             val it = 23: int
                      p.
                          If you need an if block inside the then block, you will need to wrap it
                          in parentheses to disambiguate the ending else. But if an if block follows
                          another if block in the <code>else</code> section, you don't need
                          parentheses:
                      pre
                          code.
                              > val i = if true then 1 else if false then 11 else 14;
  