   ]
 
   Switch: [
-    o "SWITCH Expression INDENT Whens OUTDENT", -> new Switch $2, $4
-    o "SWITCH Expression INDENT Whens ELSE Block OUTDENT", -> new Switch $2, $4, $6
-    o "SWITCH INDENT Whens OUTDENT",            -> new Switch null, $3
-    o "SWITCH INDENT Whens ELSE Block OUTDENT", -> new Switch null, $3, $5
+    o 'SWITCH Expression INDENT Whens OUTDENT',            -> new Switch $2, $4
+    o 'SWITCH Expression INDENT Whens ELSE Block OUTDENT', -> new Switch $2, $4, $6
+    o 'SWITCH INDENT Whens OUTDENT',                       -> new Switch null, $3
+    o 'SWITCH INDENT Whens ELSE Block OUTDENT',            -> new Switch null, $3, $5
   ]
 
   Whens: [
-    o "When"
-    o "Whens When",                             -> $1.concat $2
+    o 'When'
+    o 'Whens When',                             -> $1.concat $2
   ]
 
   # An individual **When** clause, with action.
   When: [
-    o "LEADING_WHEN SimpleArgs Block",            -> [[$2, $3]]
-    o "LEADING_WHEN SimpleArgs Block TERMINATOR", -> [[$2, $3]]
+    o 'LEADING_WHEN SimpleArgs Block',            -> [[$2, $3]]
+    o 'LEADING_WHEN SimpleArgs Block TERMINATOR', -> [[$2, $3]]
   ]
 
   # The most basic form of *if* is a condition and an action. The following
   # if-related rules are broken up along these lines in order to avoid
   # ambiguity.
   IfBlock: [
-    o "IF Expression Block",                    -> new If $2, $3
-    o "UNLESS Expression Block",                -> new If $2, $3, invert: true
-    o "IfBlock ELSE IF Expression Block",       -> $1.addElse new If $4, $5
-    o "IfBlock ELSE Block",                     -> $1.addElse $3
+    o 'IF Expression Block',                    -> new If $2, $3
+    o 'UNLESS Expression Block',                -> new If $2, $3, invert: true
+    o 'IfBlock ELSE IF Expression Block',       -> $1.addElse new If $4, $5
+    o 'IfBlock ELSE Block',                     -> $1.addElse $3
   ]
 
   # The full complement of *if* expressions, including postfix one-liner
   # *if* and *unless*.
   If: [
-    o "IfBlock"
-    o "Statement POST_IF Expression",           -> new If $3, Expressions.wrap([$1]), statement: true
-    o "Expression POST_IF Expression",          -> new If $3, Expressions.wrap([$1]), statement: true
-    o "Statement POST_UNLESS Expression",       -> new If $3, Expressions.wrap([$1]), statement: true, invert: true
-    o "Expression POST_UNLESS Expression",      -> new If $3, Expressions.wrap([$1]), statement: true, invert: true
+    o 'IfBlock'
+    o 'Statement  POST_IF Expression',     ->
+      new If $3, Expressions.wrap([$1]), statement: true
+    o 'Expression POST_IF Expression',     ->
+      new If $3, Expressions.wrap([$1]), statement: true
+    o 'Statement  POST_UNLESS Expression', ->
+      new If $3, Expressions.wrap([$1]), statement: true, invert: true
+    o 'Expression POST_UNLESS Expression', ->
+      new If $3, Expressions.wrap([$1]), statement: true, invert: true
   ]
 
   # Arithmetic and logical operators, working on one or more operands.

  # The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
  # all parsing must end here.
  Root: [
    o "",                                       -> new Expressions
    o "TERMINATOR",                             -> new Expressions
    o "Body"
    o "Block TERMINATOR"
  ]

  # Any list of statements and expressions, seperated by line breaks or semicolons.
  Body: [
    o "Line",                                   -> Expressions.wrap [$1]
    o "Body TERMINATOR Line",                   -> $1.push $3
    o "Body TERMINATOR"
  ]

  # Expressions and statements, which make up a line in a body.
  Line: [
    o "Expression"
    o "Statement"
  ]

  # Pure statements which cannot be expressions.
  Statement: [
    o "Return"
    o "Throw"
    o "BREAK",                                  -> new Literal $1
    o "CONTINUE",                               -> new Literal $1
    o "DEBUGGER",                               -> new Literal $1
  ]

  # All the different types of expressions in our language. The basic unit of

  # where only values are accepted, wrapping it in parentheses will always do
  # the trick.
  Parenthetical: [
    o '( Expression )',                         -> new Parens $2
  ]

  # The condition portion of a while loop.
  WhileSource: [
    o 'WHILE Expression',                       -> new While $2
    o 'WHILE Expression WHEN Expression',       -> new While $2, guard: $4
    o 'UNTIL Expression',                       -> new While $2, invert: true
    o 'UNTIL Expression WHEN Expression',       -> new While $2, invert: true, guard: $4
  ]

  # The while loop can either be normal, with a block of expressions to execute,
  # or postfix, with a single expression. There is no do..while.
  While: [
    o 'WhileSource Block',                      -> $1.addBody $2
    o 'Statement  WhileSource',                 -> $2.addBody Expressions.wrap [$1]
    o 'Expression WhileSource',                 -> $2.addBody Expressions.wrap [$1]
    o 'Loop',                                   -> $1
  ]

  Loop: [
    o 'LOOP Block',      -> new While(new Literal 'true').addBody $2
    o 'LOOP Expression', -> new While(new Literal 'true').addBody Expressions.wrap [$2]
  ]

  # Array, object, and range comprehensions, at the most generic level.
