From 5d59d510cd6fdc8553250e5ec10f19a285e8878c Mon Sep 17 00:00:00 2001
From: Bruce Hill <bitbucket@bruce-hill.com>
Date: Wed, 25 Apr 2018 16:30:49 -0700
Subject: [PATCH] Removing end-of-line ":" and "(..)" for blocks (they just use
 indentation now).

---
 core/collections.nom     |  56 ++++++++---------
 core/control_flow.nom    | 126 +++++++++++++++++++--------------------
 core/math.nom            |  16 ++---
 core/metaprogramming.nom |  72 +++++++++++-----------
 core/operators.nom       |  30 +++++-----
 core/text.nom            |   2 +-
 lib/file_hash.nom        |   6 +-
 lib/object.nom           |  14 ++---
 lib/object2.nom          |  18 +++---
 lib/training_wheels.nom  |  30 +++++-----
 nomsu.peg                |   2 +-
 nomsu_tree.lua           |  30 ++++++----
 nomsu_tree.moon          |  24 ++++----
 tests/object.nom         |  10 ++--
 tests/text.nom           |   4 +-
 15 files changed, 225 insertions(+), 215 deletions(-)

diff --git a/core/collections.nom b/core/collections.nom
index d4d4c5b..97bc7ad 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -9,18 +9,18 @@ use "core/operators.nom"
 # List/dict functions:
 
 # Indexing
-immediately:
+immediately
     compile [..]
         %index st to last in %list, %index nd to last in %list, %index rd to last in %list
         %index th to last in %list
     ..to: Lua value "utils.nth_to_last(\(%list as lua expr), \(%index as lua expr))"
 
-immediately:
+immediately
     parse [first in %list, first %list] as: 1 st in %list
     parse [last in %list, last %list] as: 1 st to last in %list
 
 # Membership testing
-immediately:
+immediately
     action [%item is in %list, %list contains %item, %list has %item]
         for %key = %value in %list
             if (%key is %item): return (yes)
@@ -30,12 +30,12 @@ immediately:
         %item isn't in %list, %item is not in %list
         %list doesn't contain %item, %list does not contain %item
         %list doesn't have %item, %list does not have %item
-    ..:
+    ..
         for %key = %value in %list
             if (%key is %item): return (no)
         return (yes)
 
-immediately:
+immediately
     # Note: it's important to have the space after "[" to prevent confusion if %index is a string
     compile [%list has key %index, %list has index %index] to
         Lua value ".."
@@ -47,21 +47,21 @@ immediately:
         %list doesn't have index %index, %list does not have index %index
     ..to: Lua value "((\(%list as lua expr))[ \(%index as lua expr)] == nil)"
 
-    compile [number of keys in %list] to:
+    compile [number of keys in %list] to
         Lua value "utils.size(\(%list as lua expr))"
 
-    compile [append %item to %list, add %item to %list, to %list add %item, to %list append %item] to:
+    compile [append %item to %list, add %item to %list, to %list add %item, to %list append %item] to
         Lua "table.insert(\(%list as lua expr), \(%item as lua expr))"
 
-    compile [pop from %list, remove last from %list] to:
+    compile [pop from %list, remove last from %list] to
         Lua "table.remove(\(%list as lua expr))"
 
-    compile [remove index %index from %list] to:
+    compile [remove index %index from %list] to
         Lua "table.remove(\(%list as lua expr), \(%index as lua expr))"
 
 # List Comprehension
-immediately:
-    compile [%expression for %item in %iterable] to:
+immediately
+    compile [%expression for %item in %iterable] to
         assume (%item.type is "Var") or barf ".."
             List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type)
         return
@@ -78,7 +78,7 @@ immediately:
     compile [..]
         %expression for %index from %start to %stop via %step
         %expression for %index from %start to %stop by %step
-    ..to:
+    ..to
         assume (%index.type is "Var") or barf ".."
             List comprehension has the wrong type for the loop variable. Expected Var, but got: \(%index.type)
         return
@@ -98,7 +98,7 @@ immediately:
     ..as: %expression for % from %start to %stop via %step
     parse [%expression for all %start to %stop] as: %expression for all %start to %stop via 1
 
-    compile [%expression for %key = %value in %iterable] to:
+    compile [%expression for %key = %value in %iterable] to
         assume (%key.type is "Var") or barf ".."
             List comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%key.type)
         assume (%value.type is "Var") or barf ".."
@@ -114,8 +114,8 @@ immediately:
                 end)()
 
 # Dict comprehensions
-immediately:
-    compile [%key = %value for %item in %iterable] to:
+immediately
+    compile [%key = %value for %item in %iterable] to
         assume (%item.type is "Var") or barf ".."
             Dict comprehension has the wrong type for the loop variable. Expected Var, but got: \(%item.type)
         # Note: it's important to have the space after "[" to prevent confusion if %key is a string
@@ -130,7 +130,7 @@ immediately:
                 end)()
     parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
 
-    compile [%key = %value for %src_key = %src_value in %iterable] to:
+    compile [%key = %value for %src_key = %src_value in %iterable] to
         assume (%src_key.type is "Var") or barf ".."
             Dict comprehension has the wrong type for the key loop variable. Expected Var, but got: \(%src_key.type)
         assume (%src_value.type is "Var") or barf ".."
@@ -146,11 +146,11 @@ immediately:
                     return comprehension;
                 end)()
 
-immediately:
-    action [%lists flattened]:
+immediately
+    action [%lists flattened]
         %flat <- []
-        for %list in %lists:
-            for %item in %list:
+        for %list in %lists
+            for %item in %list
                 add %item to %flat
         return %flat
 
@@ -158,8 +158,8 @@ immediately:
     parse [keys in %dict] as: %k for %k = %v in %dict
     parse [values in %dict] as: %v for %k = %v in %dict
 
-# Sorting:
-immediately:
+# Sorting
+immediately
     compile [sort %items] to: Lua "table.sort(\(%items as lua expr));"
     compile [sort %items by %key_expr] to
         Lua ".."
@@ -167,26 +167,26 @@ immediately:
                 return \(%key_expr as lua expr);
             end);
 
-immediately:
-    action [%items sorted, sorted %items]:
+immediately
+    action [%items sorted, sorted %items]
         %copy <- (% for all %items)
         sort %copy
         return %copy
-    action [%items sorted by %key]:
+    action [%items sorted by %key]
         %copy <- (% for all %items)
         sort %copy by %key
         return %copy
 
-    action [unique %items]:
+    action [unique %items]
         %unique <- []
         %seen <- {}
-        for all %items:
+        for all %items
             unless: % in %seen
                 add % to %unique
                 (% in %seen) <- (yes)
         return %unique
 
-immediately:
+immediately
     # Metatable stuff
     compile [set %dict's metatable to %metatable] to
         Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
diff --git a/core/control_flow.nom b/core/control_flow.nom
index 35e5fb5..b51ecdf 100644
--- a/core/control_flow.nom
+++ b/core/control_flow.nom
@@ -7,19 +7,19 @@ use "core/text.nom"
 use "core/operators.nom"
 
 # No-Op
-immediately:
+immediately
     compile [do nothing] to: Lua ""
 
 # Conditionals
-immediately:
-    compile [if %condition %if_body] to:
+immediately
+    compile [if %condition %if_body] to
         Lua ".."
             if \(%condition as lua expr) then
                 \(%if_body as lua statements)
             end
     parse [unless %condition %unless_body] as: if (not %condition) %unless_body
 
-    compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to:
+    compile [if %condition %if_body else %else_body, unless %condition %else_body else %if_body] to
         Lua ".."
             if \(%condition as lua expr) then
                 \(%if_body as lua statements)
@@ -36,18 +36,18 @@ immediately
         %when_true_expr if %condition otherwise %when_false_expr
         %when_false_expr unless %condition else %when_true_expr
         %when_false_expr unless %condition then %when_true_expr
-    ..to:
+    ..to
         #.. If %when_true_expr is guaranteed to be truthy, we can use Lua's idiomatic
             equivalent of a conditional expression: (cond and if_true or if_false)
         if: %when_true_expr.type in {Text:yes, List:yes, Dict:yes, Number:yes}
-            return:
+            return
                 Lua value ".."
                     (\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(%when_false_expr as lua expr))
-        ..else:
+        ..else
             #.. Otherwise, need to do an anonymous inline function (yuck, too bad lua 
                 doesn't have a proper ternary operator!)
                 To see why this is necessary consider: (random()<.5 and false or 99)
-            return:
+            return
                 Lua value ".."
                     (function()
                         if \(%condition as lua expr) then
@@ -58,20 +58,20 @@ immediately
                     end)()
 
 # GOTOs
-immediately:
+immediately
     compile [=== %label ===, --- %label ---, *** %label ***] to
         Lua "::label_\(%label as lua identifier)::;"
     compile [go to %label] to
         Lua "goto label_\(%label as lua identifier);"
 
 # Basic loop control
-immediately:
+immediately
     compile [do next] to: Lua "continue;"
     compile [stop] to: Lua "break;"
 
 # Helper function
-immediately:
-    compile [if %tree has subtree %subtree where %condition %body] to:
+immediately
+    compile [if %tree has subtree %subtree where %condition %body] to
         Lua ".."
             for \(%subtree as lua expr) in coroutine.wrap(function() nomsu:walk_tree(\(%tree as lua expr)) end) do
                 if Types.is_node(\(%subtree as lua expr)) then
@@ -83,7 +83,7 @@ immediately:
             end
 
 # While loops
-immediately:
+immediately
     compile [do next repeat] to: Lua "goto continue_repeat;"
     compile [stop repeating] to: Lua "goto stop_repeat;"
     compile [repeat while %condition %body] to
@@ -91,14 +91,14 @@ immediately:
             Lua ".."
                 while \(%condition as lua expr) do
                     \(%body as lua statements)
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and ((%'s stub) is "do next repeat")
-        ..:
+        ..
             to %lua write "\n    ::continue_repeat::;"
         to %lua write "\nend --while-loop"
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and ((%'s stub) is "stop repeating")
-        ..:
+        ..
             %lua <-
                 Lua ".."
                     do -- scope of "stop repeating" label
@@ -111,7 +111,7 @@ immediately:
 
     compile [..]
         repeat %n times %body
-    ..to:
+    ..to
         %lua <-
             Lua ".."
                 for i=1,\(%n as lua expr) do
@@ -120,10 +120,10 @@ immediately:
             (%.type = "Action") and ((%'s stub) is "do next repeat")
         ..: to %lua write "\n    ::continue_repeat::;"
         to %lua write "\nend --numeric for-loop"
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and ((%'s stub) is "stop repeating")
-        ..:
-            %lua <-:
+        ..
+            %lua <-
                 Lua ".."
                     do -- scope of "stop repeating" label
                         \%lua
@@ -131,37 +131,37 @@ immediately:
                     end -- end of "stop repeating" label scope
         return %lua
 
-# For loop control flow:
-immediately:
+# For loop control flow
+immediately
     compile [stop %var] to
         Lua "goto stop_\(%var as lua identifier);"
     compile [do next %var] to
         Lua "goto continue_\(%var as lua identifier);"
 
 # Numeric range for loops
-immediately:
+immediately
     compile [..]
         for %var from %start to %stop by %step %body
         for %var from %start to %stop via %step %body
-    ..to:
+    ..to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
         assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
         %lua <-
             Lua ".."
                 for \(%var as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do
                     \(%body as lua statements)
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "do next %") and 
                     %.value.3.value is %var.value
         ..: to %lua write "\n    ::continue_\(%var as lua identifier)::;"
         to %lua write "\nend --numeric for-loop"
 
-        if %body has subtree % where:
-            (%.type = "Action") and:
-                ((%'s stub) is "stop %") and:
+        if %body has subtree % where
+            (%.type = "Action") and
+                ((%'s stub) is "stop %") and
                     %.value.2.value is %var.value
-        ..:
+        ..
             %lua <-
                 Lua ".."
                     do -- scope for stopping for-loop
@@ -171,7 +171,7 @@ immediately:
 
         return %lua
 
-immediately:
+immediately
     parse [for %var from %start to %stop %body] as: for %var from %start to %stop via 1 %body
     parse [..]
         for all %start to %stop by %step %body
@@ -180,25 +180,25 @@ immediately:
     parse [for all %start to %stop %body] as: for all %start to %stop via 1 %body
 
 # For-each loop (lua's "ipairs()")
-immediately:
-    compile [for %var in %iterable %body] to:
+immediately
+    compile [for %var in %iterable %body] to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
         assume (%var.type is "Var") or barf "Loop expected variable, not: \(%var's source code)"
         %lua <-
             Lua ".."
                 for i,\(%var as lua identifier) in ipairs(\(%iterable as lua expr)) do
                     \(%body as lua statements)
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "do next %") and
                     %.value.3.value is %var.value
         ..: to %lua write (Lua "\n    ::continue_\(%var as lua identifier)::;")
         to %lua write "\nend --foreach-loop"
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "stop %") and
                     %.value.2.value is %var.value
-        ..:
+        ..
             %lua <-
                 Lua ".."
                     do -- scope for stopping for-loop
@@ -210,8 +210,8 @@ immediately:
     parse [for all %iterable %body] as: for % in %iterable %body
 
 # Dict iteration (lua's "pairs()")
-immediately:
-    compile [for %key = %value in %iterable %body] to:
+immediately
+    compile [for %key = %value in %iterable %body] to
         # This uses Lua's approach of only allowing loop-scoped variables in a loop
         assume (%key.type is "Var") or barf "Loop expected variable, not: \(%key's source code)"
         assume (%value.type is "Var") or barf "Loop expected variable, not: \(%value's source code)"
@@ -219,13 +219,13 @@ immediately:
             Lua ".."
                 for \(%key as lua identifier),\(%value as lua identifier) in pairs(\(%iterable as lua expr)) do
                     \(%body as lua statements)
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "do next %") and
                     %.value.3.value is %key.value
         ..: to %lua write (Lua "\n    ::continue_\(%key as lua identifier)::;")
 
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "do next %") and
                     %.value.3.value is %value.value
@@ -233,13 +233,13 @@ immediately:
         to %lua write "\nend --foreach-loop"
         
         %stop_labels <- (Lua "")
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "stop %") and
                     %.value.2.value is %key.value
         ..: to %stop_labels write "\n::stop_\(%key as lua identifier)::;"
 
-        if %body has subtree % where:
+        if %body has subtree % where
             (%.type = "Action") and
                 ((%'s stub) is "stop %") and
                     %.value.2.value is %value.value
@@ -255,13 +255,13 @@ immediately:
         return %lua
 
 # Switch statement/multi-branch if
-immediately:
-    compile [when %body] to:
+immediately
+    compile [when %body] to
         %code <- (Lua "")
         %fallthroughs <- []
         %is_first <- (yes)
         %seen_else <- (no)
-        for %func_call in %body.value:
+        for %func_call in %body.value
             assume (%func_call.type is "Action") or barf ".."
                 Invalid format for 'when' statement. Only '*' blocks are allowed.
             %tokens <- %func_call.value
@@ -269,7 +269,7 @@ immediately:
                 %star: %tokens.1
                 %condition: %tokens.2
                 %action: %tokens.3
-            ..:
+            ..
                 assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
                     Invalid format for 'when' statement. Lines must begin with '*'
                 assume %condition or barf ".."
@@ -283,11 +283,11 @@ immediately:
                     to %code write "\nelse\n    "
                     to %code write: %action as lua statements
                     %seen_else <- (yes)
-                ..else:
+                ..else
                     assume (not %seen_else) or barf "'else' clause needs to be last in 'when' block"
                     lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
                     to %code write "\("if" if %is_first else "\nelseif") "
-                    for %i=%condition in %fallthroughs:
+                    for %i=%condition in %fallthroughs
                         if (%i > 1): to %code write " or "
                         to %code write %condition
                     to %code write " then\n    "
@@ -302,17 +302,17 @@ immediately:
         return %code
 
 # Switch statement
-immediately:
-    compile [when %branch_value = ? %body, when %branch_value is ? %body] to:
+immediately
+    compile [when %branch_value = ? %body, when %branch_value is ? %body] to
         %code <- (Lua "")
         %fallthroughs <- []
         %is_first <- (yes)
         %seen_else <- (no)
-        for %func_call in %body.value:
+        for %func_call in %body.value
             assume (%func_call.type is "Action") or barf ".."
                 Invalid format for 'when' statement. Only '*' blocks are allowed.
             %tokens <- %func_call.value
-            with {%star:%tokens.1, %condition:%tokens.2, %action:%tokens.3}:
+            with {%star:%tokens.1, %condition:%tokens.2, %action:%tokens.3}
                 assume ((%star and (%star.type is "Word")) and (%star.value is "*")) or barf ".."
                     Invalid format for 'when' statement. Lines must begin with '*'
                 assume %condition or barf ".."
@@ -325,7 +325,7 @@ immediately:
                     assume (not %is_first) or barf "'else' clause cannot be first in 'when % = ?' block"
                     to %code write "\nelse\n    "
                     to %code write: %action as lua statements
-                ..else:
+                ..else
                     assume (not %seen_else) or barf "'else' clause needs to be last in 'when % = ?' block"
                     to %code write "\("if" if %is_first else "\nelseif") "
                     lua> "table.insert(\%fallthroughs, \(%condition as lua expr));"
@@ -334,7 +334,7 @@ immediately:
                             to %code write " or "
                         if: (%.type is "Text") or (%.type is "Number")
                             to %code write "branch_value == \%"
-                        ..else:
+                        ..else
                             to %code write "utils.equivalent(branch_value, \%)"
                     to %code write "then\n    "
                     to %code write (%action as lua statements)
@@ -354,11 +354,11 @@ immediately:
         return %code
 
 # Try/except
-immediately:
+immediately
     compile [..]
         try %action and if it succeeds %success or if it barfs %fallback
         try %action and if it barfs %fallback or if it succeeds %success
-    ..to:
+    ..to
         Lua ".."
             do
                 local fell_through = false;
@@ -375,24 +375,24 @@ immediately:
                     return ret;
                 end
             end
-    parse [try %action] as:
+    parse [try %action] as
         try %action and if it succeeds: do nothing
         ..or if it barfs: do nothing
-    parse [try %action and if it barfs %fallback] as:
+    parse [try %action and if it barfs %fallback] as
         try %action and if it succeeds: do nothing
         ..or if it barfs %fallback
-    parse [try %action and if it succeeds %success] as:
+    parse [try %action and if it succeeds %success] as
         try %action and if it succeeds %success or if it barfs: do nothing
 
-# Do/finally:
-immediately:
-    compile [do %action] to:
+# Do/finally
+immediately
+    compile [do %action] to
         Lua ".."
             do
                 \(%action as lua statements)
             end --do
 
-    compile [do %action then always %final_action] to:
+    compile [do %action then always %final_action] to
         Lua ".."
             do
                 local fell_through = false;
diff --git a/core/math.nom b/core/math.nom
index 0df8f16..75e41b4 100644
--- a/core/math.nom
+++ b/core/math.nom
@@ -34,37 +34,37 @@ compile [log % base %base, log_%base %, log base %base %] to: Lua value "math.lo
 compile [floor %] to: Lua value "math.floor(\(% as lua expr))"
 compile [ceiling %, ceil %] to: Lua value "math.ceil(\(% as lua expr))"
 compile [round %, % rounded] to: Lua value "math.floor(\(% as lua expr) + .5)"
-action [%n to the nearest %rounder]:
+action [%n to the nearest %rounder]
     =lua "(\%rounder)*math.floor((\%n / \%rounder) + .5)"
 
 # Any/all/none
-compile [all of %items, all %items] to:
+compile [all of %items, all %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.all(\(%items as lua expr))"
     %clauses <- []
     for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " and "))"
 parse [not all of %items, not all %items] as: not (all of %items)
-compile [any of %items, any %items] to:
+compile [any of %items, any %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.any(\(%items as lua expr))"
     %clauses <- []
     for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " or "))"
 parse [none of %items, none %items] as: not (any of %items)
-compile [sum of %items, sum %items] to:
+compile [sum of %items, sum %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.sum(\(%items as lua expr))"
     %clauses <- []
     for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " + "))"
-compile [product of %items, product %items] to:
+compile [product of %items, product %items] to
     unless: (%items' "type") is "List"
         return: Lua value "utils.product(\(%items as lua expr))"
     %clauses <- []
     for all (%items' "value"): lua> "table.insert(\%clauses, \(% as lua expr));"
     return: Lua value "(\(%clauses joined with " * "))"
-action [avg of %items, average of %items]:
+action [avg of %items, average of %items]
     =lua "(utils.sum(\%items)/#\%items)"
 compile [min of %items, smallest of %items, lowest of %items] to
     Lua value "utils.min(\(%items as lua expr))"
@@ -82,7 +82,7 @@ compile [max of %items by %value_expr] to
         end)
 
 # Random functions
-action [seed random with %]:
+action [seed random with %]
     lua> ".."
         math.randomseed(\%);
         for i=1,20 do math.random(); end
@@ -91,5 +91,5 @@ compile [random number, random, rand] to: Lua value "math.random()"
 compile [random int %n, random integer %n, randint %n] to: Lua value "math.random(\(%n as lua expr))"
 compile [random from %low to %high, random number from %low to %high, rand %low %high] to
     "math.random(\(%low as lua expr), \(%high as lua expr))"
-action [random choice from %elements, random choice %elements, random %elements]:
+action [random choice from %elements, random choice %elements, random %elements]
     =lua "\%elements[math.random(#\%elements)]"
diff --git a/core/metaprogramming.nom b/core/metaprogramming.nom
index f03f8d5..9722afd 100644
--- a/core/metaprogramming.nom
+++ b/core/metaprogramming.nom
@@ -3,7 +3,7 @@
     functions to make that easier.
 
 # Compile-time action to make compile-time actions:
-immediately:
+immediately
     lua> ".."
         nomsu:define_compile_action("compile %actions to %lua", \(!! code location !!), function(tree, \%actions, \%lua)
             local lua = Lua(tree.source, "nomsu:define_compile_action(");
@@ -31,15 +31,15 @@ immediately:
             end
             local body_lua = \%lua:as_lua(nomsu);
             body_lua:convert_to_statements("return ");
-            body_lua:remove_free_vars(args);
+            body_lua:remove_free_vars(unpack(args));
             body_lua:declare_locals();
             lua:append(")\\n    ", body_lua, "\\nend);");
             return lua;
         end);
 
 # Compile-time action to make actions
-immediately:
-    compile [action %actions %body] to:
+immediately
+    compile [action %actions %body] to
         lua> ".."
             local lua = Lua(tree.source, "nomsu:define_action(");
             local stubs = {};
@@ -63,14 +63,14 @@ immediately:
             end
             local body_lua = \%body:as_lua(nomsu);
             body_lua:convert_to_statements("return ");
-            body_lua:remove_free_vars(args);
+            body_lua:remove_free_vars(unpack(args));
             body_lua:declare_locals();
             lua:append(")\\n    ", body_lua, "\\nend);")
             return lua;
 
-# Macro to make nomsu macros:
-immediately:
-    compile [parse %shorthand as %longhand] to:
+# Macro to make nomsu macros
+immediately
+    compile [parse %shorthand as %longhand] to
         lua> ".."
             local lua = Lua(tree.source, "nomsu:define_compile_action(");
             local stubs = {};
@@ -104,7 +104,7 @@ immediately:
             ]]);
             return lua;
 
-action [remove action %stub]:
+action [remove action %stub]
     lua> ".."
         local fn = ACTIONS[\%stub];
         local metadata = nomsu.action_metadata[fn];
@@ -114,11 +114,11 @@ action [remove action %stub]:
         end
         ACTIONS[\%stub] = nil;
 
-immediately:
-    action [%tree as lua]:
+immediately
+    action [%tree as lua]
         =lua "\%tree:as_lua(nomsu)"
 
-    action [%tree as lua expr]:
+    action [%tree as lua expr]
         lua> ".."
             local lua = \%tree:as_lua(nomsu);
             if not lua.is_value then
@@ -126,7 +126,7 @@ immediately:
             end
             return lua;
 
-    action [%tree as lua statements]:
+    action [%tree as lua statements]
         lua> ".."
             local lua = \%tree:as_lua(nomsu);
             lua:convert_to_statements();
@@ -138,37 +138,37 @@ immediately:
     compile [declare locals %locals in %tree] to
         Lua "\(%tree as lua expr):declare_locals(\(%locals as lua expr));"
     
-    compile [remove free vars %vars from %tree] to:
+    compile [remove free vars %vars from %tree] to
         Lua "\(%tree as lua expr):remove_free_vars(unpack(\(%vars as lua expr)));"
 
-    action [%tree as value]:
+    action [%tree as value]
         =lua "nomsu:tree_to_value(\%tree)"
 
     
-    action [%tree's stub]:
+    action [%tree's stub]
         =lua "nomsu:tree_to_stub(\%tree)"
     
-immediately:
+immediately
     parse [%var <-write %code] as: lua> "\%var:append(\%code);"
     parse [to %var write %code] as: lua> "\%var:append(\%code);"
 
-immediately:
-    action [%tree's source code, %tree' source code]:
+immediately
+    action [%tree's source code, %tree' source code]
         =lua "\%tree.source:get_text()"
 
     compile [repr %obj] to: Lua value "repr(\(%obj as lua expr))"
     compile [%obj as text] to: Lua value "tostring(\(%obj as lua expr))"
     compile [type of %obj] to: Lua value "type(\(%obj as lua expr))"
 
-immediately:
+immediately
     compile [nomsu] to: Lua value "nomsu"
     compile [%var as lua identifier] to: Lua value "nomsu:var_to_lua_identifier(\(%var as lua expr))"
 
-action [action %names metadata]:
+action [action %names metadata]
     =lua "nomsu.action_metadata[ACTIONS[\%names]]"
 
 # Get the source code for a function
-action [help %action]:
+action [help %action]
     lua> ".."
         local metadata = \(action %action metadata);
         if not metadata then
@@ -178,20 +178,20 @@ action [help %action]:
         end
 
 # Compiler tools
-immediately:
-    compile [run %code] to:
+immediately
+    compile [run %code] to
         Lua value "nomsu:run(Nomsu(\(=lua "tostring(tree.source)"), \(%code as lua expr)))"
     parse [enable debugging] as: lua> "nomsu.debug = true;"
     parse [disable debugging] as: lua> "nomsu.debug = false;"
 
-immediately:
-    compile [show lua %block] to:
+immediately
+    compile [show lua %block] to
         lua> ".."
             local \%lua = \%block:as_lua(nomsu);
             return Lua(\%block.source, "print(", repr(tostring(\%lua)), ");");
 
-immediately:
-    compile [say %message] to:
+immediately
+    compile [say %message] to
         lua> ".."
             if \%message.type == "Text" then
                 return Lua(tree.source, "print(", \(%message as lua expr), ");");
@@ -199,42 +199,42 @@ immediately:
                 return Lua(tree.source, "print(stringify(", \(%message as lua expr), "));");
             end
 
-immediately:
+immediately
     compile [source] to: Lua value (=lua "tree.source") "tree.source"
 
 #..
-    immediately:
+    immediately
         action [Lua %]: Lua (=lua "tree.source") %
         action [Lua value %]: Lua value (=lua "tree.source") %
 
 # Return
-immediately:
+immediately
     #.. Return statement is wrapped in a do..end block because Lua is unhappy if you
         put code after a return statement, unless you wrap it in a block.
     compile [return] to: Lua "do return; end"
     compile [return %return_value] to: Lua "do return \(%return_value as lua expr); end"
 
 # Error functions
-immediately:
+immediately
     compile [barf] to: Lua "error(nil, 0);"
     compile [barf %msg] to: Lua "error(\(%msg as lua expr), 0);"
-    compile [assume %condition] to:
+    compile [assume %condition] to
         lua> "local \%assumption = 'Assumption failed: '..tostring(\%condition.source:get_text());"
-        return:
+        return
             Lua ".."
                 if not \(%condition as lua expr) then
                     error(\(repr %assumption), 0);
                 end
     
     # TODO: factor this out and replace with "unless %condition: barf %message"
-    compile [assume %condition or barf %message] to:
+    compile [assume %condition or barf %message] to
         Lua ".."
             if not \(%condition as lua expr) then
                 error(\(%message as lua expr), 0);
             end
 
 # Literals
-immediately:
+immediately
     compile [yes] to: Lua value "true"
     compile [no] to: Lua value "false"
     compile [nothing, nil, null] to: Lua value "nil"
diff --git a/core/operators.nom b/core/operators.nom
index 073936e..a9deec1 100644
--- a/core/operators.nom
+++ b/core/operators.nom
@@ -3,8 +3,8 @@
 
 use "core/metaprogramming.nom"
 
-# Indexing:
-immediately:
+# Indexing
+immediately
     #.. NOTE!!! It's critical that there are spaces around %key if it's a string,
         otherwise, Lua will get confused and interpret %obj[[[foo]]] as %obj("[foo]")
         instead of %obj[ "foo" ].
@@ -17,13 +17,13 @@ immediately:
     ..as: %obj.%key
 
 # Comparison Operators
-immediately:
+immediately
     compile [%x < %y] to: Lua value "(\(%x as lua expr) < \(%y as lua expr))"
     compile [%x > %y] to: Lua value "(\(%x as lua expr) > \(%y as lua expr))"
     compile [%x <= %y] to: Lua value "(\(%x as lua expr) <= \(%y as lua expr))"
     compile [%x >= %y] to: Lua value "(\(%x as lua expr) >= \(%y as lua expr))"
     # TODO: optimize case of [%x,%y] = [1,2]
-    compile [%a is %b, %a = %b, %a == %b] to:
+    compile [%a is %b, %a = %b, %a == %b] to
         lua> ".."
             local safe = {Text=true, Number=true};
             local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
@@ -32,7 +32,7 @@ immediately:
             else
                 return Lua.Value(tree.source, "utils.equivalent(", a_lua, ", ", b_lua, ")");
             end
-    compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to:
+    compile [%a isn't %b, %a is not %b, %a not= %b, %a != %b] to
         lua> ".."
             local safe = {Text=true, Number=true};
             local a_lua, b_lua = \%a:as_lua(nomsu), \%b:as_lua(nomsu);
@@ -45,8 +45,8 @@ immediately:
     compile [%'s id, id of %] to: Lua value "nomsu.ids[\(% as lua expr)]"
 
 # Variable assignment operator
-immediately:
-    compile [%var <- %value] to:
+immediately
+    compile [%var <- %value] to
         lua> "local \%var_lua = \%var:as_lua(nomsu);"
         assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
         lua> "local \%value_lua = \%value:as_lua(nomsu);"
@@ -58,9 +58,9 @@ immediately:
             end
             return lua;
 
-immediately:
+immediately
     # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
-    compile [<- %assignments] to:
+    compile [<- %assignments] to
         assume ((%assignments' "type") is "Dict") or barf ".."
             Expected a Dict for the assignments part of '<- %' statement, not \(%assignments' source code)
         lua> ".."
@@ -83,20 +83,20 @@ immediately:
             end
             return Lua(tree.source, lhs, " = ", rhs, ";");
 
-immediately:
-    compile [export %var <- %value] to:
+immediately
+    compile [export %var <- %value] to
         %var_lua <- (%var as lua)
         assume %var_lua.is_value or barf "Invalid target for assignment: \(%var's source code)"
         %value_lua <- (%value as lua)
         assume %value_lua.is_value or barf "Invalid value for assignment: \(%value's source code)"
         return: Lua "\(%var_lua) = \(%value_lua);"
 
-    compile [exporting %exported %body] to:
+    compile [exporting %exported %body] to
         %body_lua <- (%body as lua statements)
         lua> "\%body_lua:remove_free_vars(unpack(\(%exported.value)));"
         return %body_lua
 
-    compile [with %assignments %body] to:
+    compile [with %assignments %body] to
         %lua <- (%body as lua statements)
         lua> ".."
             local lhs, rhs = Lua(tree.source), Lua(\%assignments.source);
@@ -130,7 +130,7 @@ immediately:
                     \%lua
                 end -- 'with' block
 
-immediately:
+immediately
     # Math Operators
     compile [%x + %y] to: Lua value "(\(%x as lua expr) + \(%y as lua expr))"
     compile [%x - %y] to: Lua value "(\(%x as lua expr) - \(%y as lua expr))"
@@ -171,7 +171,7 @@ immediately:
     compile [length of %list] to: Lua value "(#\(%list as lua expr))"
 
 # Update operators
-immediately:
+immediately
     parse [%var + <- %, %var +<- %] as: %var <- (%var + %)
     parse [%var - <- %, %var -<- %] as: %var <- (%var - %)
     parse [%var * <- %, %var *<- %] as: %var <- (%var * %)
diff --git a/core/text.nom b/core/text.nom
index 71e1ce1..835ef87 100644
--- a/core/text.nom
+++ b/core/text.nom
@@ -5,7 +5,7 @@
 use "core/metaprogramming.nom"
 
 # Text functions
-action [%texts joined with %glue]:
+action [%texts joined with %glue]
     lua> ".."
         local text_bits = {}
         for i,bit in ipairs(\%texts) do text_bits[i] = stringify(bit) end
diff --git a/lib/file_hash.nom b/lib/file_hash.nom
index 4d99e39..0d7e523 100644
--- a/lib/file_hash.nom
+++ b/lib/file_hash.nom
@@ -28,15 +28,15 @@ lua> ".."
     end
     attrdir(".");
 
-action [sha1 %]:
+action [sha1 %]
     lua> "return sha1(\%);"
 
-action [file with hash %hash]:
+action [file with hash %hash]
     %file <- (%hash in %hash_to_filename)
     assume %file or barf "File with SHA1 hash \%hash not found!"
     return %file
 
-action [hash of file %filename]:
+action [hash of file %filename]
     lua> ".."
         local f = io.open(\%filename);
         local hash = sha1(f:read("*a"));
diff --git a/lib/object.nom b/lib/object.nom
index ca664b5..0bb2538 100644
--- a/lib/object.nom
+++ b/lib/object.nom
@@ -1,6 +1,6 @@
 use "core"
 
-compile [@%var] to:
+compile [@%var] to
     lua> ".."
         local key_lua = repr(\%var.value);
         local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'")
@@ -12,7 +12,7 @@ compile [@%var] to:
         end
         return {expr="_me["..key_lua.."]"};
 
-compile [@%var <- %val] to:
+compile [@%var <- %val] to
     lua> ".."
         local val_lua = \(%val as lua expr);
         local key_lua = repr(\%var.value);
@@ -25,12 +25,12 @@ compile [@%var <- %val] to:
         end
         return {statements="_me["..key_lua.."] = "..val_lua..";"};
 
-compile [define object %classname %class_body] to:
+compile [define object %classname %class_body] to
     %class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
     if: %class_identifier is ""
         %class_identifier <- "class"
     %methods <- []
-    for %line in (%class_body's "value"):
+    for %line in (%class_body's "value")
         if: (%line's "type") is "Comment"
             do next %line
         assume (((%line's "type") == "FunctionCall") and ((%line's stub) == "action % %"))
@@ -86,7 +86,7 @@ compile [define object %classname %class_body] to:
     return {..}
         statements:".."
             do -- \%class_identifier
-                -- Create the class object:
+                -- Create the class object
                 local \%class_identifier = setmetatable({
                     name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}),
                 }, {
@@ -104,10 +104,10 @@ compile [define object %classname %class_body] to:
                 });
                 \%class_identifier.class = \%class_identifier;
 
-                -- Define the methods:
+                -- Define the methods
             \(%methods joined with "\n")
 
-                -- Define class methods for instantiating and accessing instances:
+                -- Define class methods for instantiating and accessing instances
                 \%class_identifier.instance_metatable = {
                     __index=\%class_identifier,
                     __tostring=\%class_identifier['% as text'] or function(inst)
diff --git a/lib/object2.nom b/lib/object2.nom
index 762ab4d..863ee2a 100644
--- a/lib/object2.nom
+++ b/lib/object2.nom
@@ -2,7 +2,7 @@ use "core"
 
 compile [@] to: Lua value "self"
 
-compile [@%var] to:
+compile [@%var] to
     lua> ".."
         local key_lua = repr(\%var.value);
         local key_attr = (key_lua:match("'([a-zA-Z][a-zA-Z0-9]*)'")
@@ -14,7 +14,7 @@ compile [@%var] to:
         end
         return Lua.Value(tree.source, "self["..key_lua.."]");
 
-compile [@%var <- %val] to:
+compile [@%var <- %val] to
     lua> ".."
         local val_lua = \(%val as lua expr);
         local key_lua = repr(\%var.value);
@@ -27,7 +27,7 @@ compile [@%var <- %val] to:
         end
         return Lua(tree.source, "self[", key_lua, "] = ", val_lua, ";");
 
-compile [as %instance %body] to:
+compile [as %instance %body] to
     %body_lua <- (%body as lua)
     lua> "\%body_lua:convert_to_statements();"
     return
@@ -43,21 +43,21 @@ compile [as %instance %body] to:
             \%body_lua
             end
 
-compile [define object %classname %class_body] to:
+compile [define object %classname %class_body] to
     %class_identifier <- (=lua "nomsu:var_to_lua_identifier(\(%classname as value)):sub(2,-1)")
     if: %class_identifier is ""
         %class_identifier <- "class"
     %methods <- []
     %__index <- %class_identifier
     %__newindex <- "nil"
-    for %line in (%class_body's "value"):
+    for %line in (%class_body's "value")
         if: (%line's "type") is "Comment"
             do next %line
         if: ((%line's "type") is "FunctionCall") and ((%line's stub) is "slots %")
             %slot_index_clauses <- []
             %slot_newindex_clauses <- []
             %slots <- %line.value.2.value
-            for %slot_index = %slot_var in %slots:
+            for %slot_index = %slot_var in %slots
                 to %slot_index_clauses add ".."
                     if key == \(repr (%slot_var's "value")) or key == \(repr (%slot_var as lua expr)) then
                         return rawget(self, \%slot_index);
@@ -115,7 +115,7 @@ compile [define object %classname %class_body] to:
     return
         Lua ".."
             do -- \%class_identifier
-                -- Create the class object:
+                -- Create the class object
                 local \%class_identifier = setmetatable({
                     name=\(%classname as lua expr), instances=setmetatable({}, {__mode="k"}),
                 }, {
@@ -132,10 +132,10 @@ compile [define object %classname %class_body] to:
                 });
                 \%class_identifier.class = \%class_identifier;
 
-                -- Define the methods:
+                -- Define the methods
             \(%methods joined with "\n")
 
-                -- Define class methods for instantiating and accessing instances:
+                -- Define class methods for instantiating and accessing instances
                 \%class_identifier.instance_metatable = {
                     __index=\%__index,
                     __newindex=\%__newindex,
diff --git a/lib/training_wheels.nom b/lib/training_wheels.nom
index e5c02fb..1f524da 100644
--- a/lib/training_wheels.nom
+++ b/lib/training_wheels.nom
@@ -26,19 +26,19 @@ parse [error!, panic!, fail!, abort!] as: barf!
 parse [error %, panic %, fail %, abort %] as: barf %
 parse [assert %condition %message] as: assume %condition or barf %message
 parse [%cond ? %if_true %if_false] as: %if_true if %cond else %if_false
-compile [function %args %body, lambda %args %body] to:
-    %body_lua <- (%body as lua)
-    %statements <- ((%body_lua's "statements") or "return \(%body_lua's "expr");")
-    %locals <- (% for all ((%body_lua's "locals") or []))
-    for all (%args's "value"):
-        lua> "utils.remove_from_list(\%locals, \(% as lua expr));"
-    if: (size of %locals) > 0
-        %statements <- "local \(%locals joined with ", ");\n\%statements"
-
-    return {..}
-        expr: ".."
-            (function(\(((% as lua expr) for all (%args's "value")) joined with ", "))
-                \%statements
-            end)
+compile [function %args %body, lambda %args %body] to
+    %lua <-: Lua value "(function("
+    for %i = %arg in %args.value
+        if: %i > 1
+            to %lua write ", "
+        to %lua write: %arg as lua expr
+    to %lua write ")\n    "
+    %body <-: %body as lua
+    lua> "\%body:convert_to_statements('return ');"
+    for all %args.value: lua> "\%body:remove_free_vars(\%);"
+    to %lua write %body
+    to %lua write "\nend)"
+    return %lua
 parse [function %name %args %body] as: %name <- (function %args %body)
-compile [call %fn %args] to {expr:"\(%fn as lua expr)(unpack(\(%args as lua expr)))"}
+compile [call %fn %args] to
+    Lua value "\(%fn as lua expr)(unpack(\(%args as lua expr)))"
diff --git a/nomsu.peg b/nomsu.peg
index 7e72011..af65d93 100644
--- a/nomsu.peg
+++ b/nomsu.peg
@@ -10,7 +10,7 @@ shebang: "#!" [^%nl]* (!. / %nl)
 statement: action / expression
 
 indented_block (Block):
-    {| (":" / "(..)")? indent
+    {| indent
             statement (nodent statement)*
         (dedent / (("" -> "Error while parsing block") => error))
     |} -> Tuple
diff --git a/nomsu_tree.lua b/nomsu_tree.lua
index 01e08de..4a3d7f6 100644
--- a/nomsu_tree.lua
+++ b/nomsu_tree.lua
@@ -14,6 +14,7 @@ do
   local _obj_0 = require("lua_obj")
   Lua, Nomsu, Location = _obj_0.Lua, _obj_0.Nomsu, _obj_0.Location
 end
+local MAX_LINE = 80
 local Types = { }
 Types.DictEntry = immutable({
   "key",
@@ -307,21 +308,24 @@ Tree("Action", {
       return nomsu
     else
       local inline_version = self:as_nomsu(true)
-      if inline_version and #inline_version <= 80 then
+      if inline_version and #inline_version <= MAX_LINE then
         return inline_version
       end
       local nomsu = Nomsu(self.source)
       local spacer = nil
       for i, bit in ipairs(self.value) do
-        if spacer then
-          nomsu:append(spacer)
-        end
         if bit.type == "Word" then
+          if spacer then
+            nomsu:append(spacer)
+          end
           nomsu:append(bit.value)
           spacer = " "
         else
           local arg_nomsu = bit:as_nomsu(true)
-          if arg_nomsu and #arg_nomsu < 80 then
+          if arg_nomsu and #arg_nomsu < MAX_LINE then
+            if spacer then
+              nomsu:append(spacer)
+            end
             if bit.type == "Action" or bit.type == "Block" then
               arg_nomsu:parenthesize()
             end
@@ -333,6 +337,10 @@ Tree("Action", {
             end
             if bit.type == "Action" or bit.type == "Block" then
               nomsu:append("\n    ")
+            else
+              if spacer then
+                nomsu:append(spacer)
+              end
             end
             spacer = "\n.."
           end
@@ -423,7 +431,7 @@ Tree("Text", {
       return nomsu
     else
       local inline_version = self:as_nomsu(true)
-      if inline_version and #inline_version <= 80 then
+      if inline_version and #inline_version <= MAX_LINE then
         return inline_version
       end
       local nomsu = Nomsu(self.source, '".."\n    ')
@@ -472,7 +480,7 @@ Tree("List", {
         line_length = line_length + #last_line
       end
       if i < #self.value then
-        if line_length >= 80 then
+        if line_length >= MAX_LINE then
           lua:append(",\n")
           line_length = 0
         else
@@ -504,7 +512,7 @@ Tree("List", {
       return nomsu
     else
       local inline_version = self:as_nomsu(true)
-      if inline_version and #inline_version <= 80 then
+      if inline_version and #inline_version <= MAX_LINE then
         return inline_version
       end
       local nomsu = Nomsu(self.source, "[..]")
@@ -513,7 +521,7 @@ Tree("List", {
       for _index_0 = 1, #_list_0 do
         local item = _list_0[_index_0]
         local item_nomsu = item:as_nomsu(true)
-        if item_nomsu and #line + #", " + #item_nomsu <= 80 then
+        if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE then
           if #line.bits > 1 then
             line:append(", ")
           end
@@ -569,7 +577,7 @@ Tree("Dict", {
         line_length = line_length + #last_line
       end
       if i < #self.value then
-        if line_length >= 80 then
+        if line_length >= MAX_LINE then
           lua:append(",\n")
           line_length = 0
         else
@@ -624,7 +632,7 @@ Tree("Dict", {
           key_nomsu:parenthesize()
         end
         local value_nomsu = entry.value:as_nomsu(true)
-        if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= 80 then
+        if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= MAX_LINE then
           if #line.bits > 1 then
             line:append(", ")
           end
diff --git a/nomsu_tree.moon b/nomsu_tree.moon
index 879f024..43ebcd2 100644
--- a/nomsu_tree.moon
+++ b/nomsu_tree.moon
@@ -8,6 +8,7 @@ immutable = require 'immutable'
 {:insert, :remove, :concat} = table
 {:Lua, :Nomsu, :Location} = require "lua_obj"
 
+MAX_LINE = 80 -- For beautification purposes, try not to make lines much longer than this value
 
 Types = {}
 Types.DictEntry = immutable({"key","value"}, {name:"DictEntry"})
@@ -177,20 +178,19 @@ Tree "Action",
             return nomsu
         else
             inline_version = @as_nomsu(true)
-            if inline_version and #inline_version <= 80
+            if inline_version and #inline_version <= MAX_LINE
                 return inline_version
             nomsu = Nomsu(@source)
             spacer = nil
             for i,bit in ipairs @value
-                if spacer
-                    nomsu\append spacer
-
                 if bit.type == "Word"
+                    if spacer then nomsu\append spacer
                     nomsu\append bit.value
                     spacer = " "
                 else
                     arg_nomsu = bit\as_nomsu(true)
-                    if arg_nomsu and #arg_nomsu < 80
+                    if arg_nomsu and #arg_nomsu < MAX_LINE
+                        if spacer then nomsu\append spacer
                         if bit.type == "Action" or bit.type == "Block"
                             arg_nomsu\parenthesize!
                         spacer = " "
@@ -199,6 +199,8 @@ Tree "Action",
                         return nil unless nomsu
                         if bit.type == "Action" or bit.type == "Block"
                             nomsu\append "\n    "
+                        else
+                            if spacer then nomsu\append spacer
                         spacer = "\n.."
                     nomsu\append arg_nomsu
             return nomsu
@@ -253,7 +255,7 @@ Tree "Text",
             return nomsu
         else
             inline_version = @as_nomsu(true)
-            if inline_version and #inline_version <= 80
+            if inline_version and #inline_version <= MAX_LINE
                 return inline_version
             nomsu = Nomsu(@source, '".."\n    ')
             for i, bit in ipairs @value
@@ -290,7 +292,7 @@ Tree "List",
             else
                 line_length += #last_line
             if i < #@value
-                if line_length >= 80
+                if line_length >= MAX_LINE
                     lua\append ",\n"
                     line_length = 0
                 else
@@ -312,13 +314,13 @@ Tree "List",
             return nomsu
         else
             inline_version = @as_nomsu(true)
-            if inline_version and #inline_version <= 80
+            if inline_version and #inline_version <= MAX_LINE
                 return inline_version
             nomsu = Nomsu(@source, "[..]")
             line = Nomsu(@source, "\n    ")
             for item in *@value
                 item_nomsu = item\as_nomsu(true)
-                if item_nomsu and #line + #", " + #item_nomsu <= 80
+                if item_nomsu and #line + #", " + #item_nomsu <= MAX_LINE
                     if #line.bits > 1
                         line\append ", "
                     line\append item_nomsu
@@ -365,7 +367,7 @@ Tree "Dict",
             else
                 line_length += #last_line
             if i < #@value
-                if line_length >= 80
+                if line_length >= MAX_LINE
                     lua\append ",\n"
                     line_length = 0
                 else
@@ -400,7 +402,7 @@ Tree "Dict",
                 if entry.key.type == "Action" or entry.key.type == "Block"
                     key_nomsu\parenthesize!
                 value_nomsu = entry.value\as_nomsu(true)
-                if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= 80
+                if value_nomsu and #line + #", " + #key_nomsu + #":" + #value_nomsu <= MAX_LINE
                     if #line.bits > 1
                         line\append ", "
                     line\append key_nomsu,":",value_nomsu
diff --git a/tests/object.nom b/tests/object.nom
index ab87fc7..a986abf 100644
--- a/tests/object.nom
+++ b/tests/object.nom
@@ -2,16 +2,16 @@ use "core"
 use "lib/object2.nom"
 
 #..
-    immediately:
-        define object "Dog":
-            action [bark]:
+    immediately
+        define object "Dog"
+            action [bark]
                 %barks <- ("Bark!" for all 1 to (@%barks))
                 return (%barks joined with " ")
-            action [get pissed off]:
+            action [get pissed off]
                 (@%barks) +<- 1
 
     %d <- (new Dog {barks:2})
-    as %d:
+    as %d
         assume ((@) = %d)
         assume ((@%barks) = 2)
         assume ((bark) = "Bark! Bark!")
diff --git a/tests/text.nom b/tests/text.nom
index 6b4f2b5..004a630 100644
--- a/tests/text.nom
+++ b/tests/text.nom
@@ -14,11 +14,11 @@ assume (("x" + "y") = "xy")
 
 say "Text test passed."
 
-immediately:
+immediately
     parse [アクション %spec %body] as: action %spec %body
 
 %こんにちは <- "こんにちは"
-アクション [% と言う]:
+アクション [% と言う]
     "\(%)世界"
 
 assume ((%こんにちは と言う) = "こんにちは世界") or barf "Unicode doesn't work"