Lolcode spec fixes

lolcode/spec/expressions.rst

@@ -21,17 +21,6 @@ Math is performed as integer math in the presence of two ``NUMBR`` s.
 If either of the arguments is a ``YARN``, the ``YARN`` is
 converted to an integer and the operation proceeds if the conversion succeeds.
 
-Precedence
-~~~~~~~~~~
-
-Multiplication, division and modulo have the highest precedence. All three
-operators have equal precedence and are evaluated left to right.
-Addition and subtraction have equal precedence and are also evaluated left to
-right.
-
-Parenthesis ('()') can be used to group operations to override precedence or
-clarify the evaluation order.
-
 Conditions
 ~~~~~~~~~~
 
@@ -42,8 +31,7 @@ LOLCODE supports two conditional operators:
     BIGGR OF <x> AN <y>     BTW max
     SMALLR OF <x> AN <y>    BTW min
 
-These operators apply to both strings and integers. Since both types are
-supported, the types of ``<x>`` and ``<y>`` must match.
+These operators apply to both strings and integers. As with the math operators above, if either argument is a ``YARN``, it is converted to an integer and the operation proceeds if the conversion succeeds.
 
 Concatenation
 ~~~~~~~~~~~~~

lolcode/spec/statements.rst

@@ -16,6 +16,8 @@ Our version of LOLCODE supports seven types of statements:
 If-then
 ~~~~~~~
 
+A bare expression statement (one not assigned to a variable) stores its result in the implicit variable ``IT``. ``IT`` holds that value until the next bare expression replaces it, and is what ``O RLY?`` and ``WTF?`` test against.
+
 An if statement begins with a comparison:
 
 Comparison is (currently) done with two binary equality operators:
@@ -179,7 +181,7 @@ Iteration loops have the form:
 
 Where ``<operation>`` may be ``UPPIN`` (increment by one) or ``NERFIN`` (decrement by one).
 That operation/function is applied to the ``<variable>``, which is temporary, and local to the loop.
-The ``TIL <expression>`` evaluates the expression as a boolean: if it evaluates as false, the loop continues once more, if not, then loop execution stops, and continues after the matching ``IM OUTTA YR <label>``. The ``WILE <expression>`` is the converse: if the expression is true, execution continues, otherwise the loop exits.
+The TIL/WILE condition, when present, is checked before each iteration of the loop body, including the first — so a loop can execute zero times. The ``TIL <expression>`` evaluates the expression as a boolean: if it evaluates as false, the loop continues once more, if not, then loop execution stops, and continues after the matching ``IM OUTTA YR <label>``. The ``WILE <expression>`` is the converse: if the expression is true, execution continues, otherwise the loop exits.
 
 .. _sssec:cast:
 

lolcode/spec/variables.rst

@@ -7,6 +7,8 @@ Scope
 All variable scope is local to the main program block.
 Variables are only accessible after declaration, and there is no global scope.
 
+Blocks introduced by ``O RLY?``/``YA RLY``/``MEBBE``/``NO WAI``, ``WTF?``/``OMG``, and ``IM IN YR``/``IM OUTTA YR`` are their own scope: a variable declared with ``I HAS A`` inside one of these blocks is only visible within that block, and ceases to exist once the block ends.
+
 Naming
 ~~~~~~
 
@@ -15,13 +17,13 @@ Variable identifiers may be in all uppercase or lowercase letters (or a mixture
 Types
 ~~~~~
 
-For the purposes of this assignment, LOLCODE only recognizes three types:
+For the purposes of this assignment, LOLCODE recognizes four types, though only three of them can be declared as variables:
 
 - **YARN** or strings. Literals are enclosed in double quotes ('"') at each end. We are not going to try to support escape characters for this assignment.
 
 - **NUMBR** or integers. Integers can be represented using the host's 32-bit implementation. Integer literals are allowed to have a leading hyphen ('-') to signify a negative number.
 
-- **TROOF** or boolean, where true is WIN and false is FAIL. Although full LOLCODE supports both variables and expressions of type TROOF, we only include it here for reference in the the descriptions taken from the spec.
+- **TROOF** or boolean, where true is WIN and false is FAIL. TROOF is a value type produced by comparisons (``BOTH SAEM``, ``DIFFRINT``) and consumed by conditionals (``O RLY?``, ``MEBBE``), but it cannot be declared as a variable or cast to with MAEK in this reduced version of the language.
 
 - **NOOB** or void. This is the type given to uninitialized variables.