From 831ad7dd8da97c0d20e7100fa4fad250ab829b30 Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:33:33 -0600
Subject: [PATCH 1/6] Define the implicit IT variable in lolcode If-then

IT was used ("if IT can be cast to WIN") without ever being introduced.
---
 lolcode/spec/statements.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lolcode/spec/statements.rst b/lolcode/spec/statements.rst
index 6898a23..0701d08 100644
--- a/lolcode/spec/statements.rst
+++ b/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:

From ec1dd42119af05e6955edd9fe2855ccfb37b229c Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:33:42 -0600
Subject: [PATCH 2/6] Clarify TIL/WILE as pre-test loop conditions in lolcode
 Loop section

---
 lolcode/spec/statements.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lolcode/spec/statements.rst b/lolcode/spec/statements.rst
index 0701d08..523f60f 100644
--- a/lolcode/spec/statements.rst
+++ b/lolcode/spec/statements.rst
@@ -181,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:
 

From 040854e836ffbdaf3272940ae6cf5af7f6673f5a Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:33:56 -0600
Subject: [PATCH 3/6] Resolve type-count contradiction in lolcode Types section

Doc claimed "three types" while listing four; clarify TROOF is a value
type produced by comparisons, not a declarable variable type.
---
 lolcode/spec/variables.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lolcode/spec/variables.rst b/lolcode/spec/variables.rst
index fc32e0a..8dd98b0 100644
--- a/lolcode/spec/variables.rst
+++ b/lolcode/spec/variables.rst
@@ -15,13 +15,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.
 

From 1359bd1d3d23d58dae2471511812b1d3a2e30422 Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:34:17 -0600
Subject: [PATCH 4/6] Remove vestigial Precedence section from lolcode
 Expressions

LOLCODE's math operators are fully bracketed by keywords (SUM OF x AN y),
so there's no ambiguous infix chain for precedence rules to resolve; this
was unadapted leftover content.
---
 lolcode/spec/expressions.rst | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/lolcode/spec/expressions.rst b/lolcode/spec/expressions.rst
index 6b829a9..2c4be35 100644
--- a/lolcode/spec/expressions.rst
+++ b/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
 ~~~~~~~~~~
 

From a06c911304c1e73b7e7ef791578c916b947cf895 Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:34:27 -0600
Subject: [PATCH 5/6] Align BIGGR OF/SMALLR OF casting rule with Math section

The "types must match" requirement contradicted this doc's own math-operator
casting rule and the official LOLCODE spec, which auto-casts YARN/NUMBR the
same way for both.
---
 lolcode/spec/expressions.rst | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/lolcode/spec/expressions.rst b/lolcode/spec/expressions.rst
index 2c4be35..9ea7df3 100644
--- a/lolcode/spec/expressions.rst
+++ b/lolcode/spec/expressions.rst
@@ -31,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
 ~~~~~~~~~~~~~

From 2c7efbe8f4a8398edd542951f7e1abb50bb00c34 Mon Sep 17 00:00:00 2001
From: Chloe Dancey <22119302+novo52@users.noreply.github.com>
Date: Tue, 28 Jul 2026 11:34:39 -0600
Subject: [PATCH 6/6] Add block-scoping rule to lolcode Scope section

The official LOLCODE spec never specifies scope more finely than
function/main-block level, leaving if/loop block scoping undefined.
State it explicitly for this course's implementation.
---
 lolcode/spec/variables.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lolcode/spec/variables.rst b/lolcode/spec/variables.rst
index 8dd98b0..1f005b3 100644
--- a/lolcode/spec/variables.rst
+++ b/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
 ~~~~~~