Lots of cleanups, including expanded use of (... compiles to "text

literal") shorthand, deprecating Lua value, and more use of Lua "..."
with text interpolations.

code_obj.lua

@@ -499,6 +499,7 @@ do
   NomsuCode = _class_0
 end
 Code.__base.add_1_joined_with = assert(Code.__base.concat_append)
+Code.__base.add = assert(Code.__base.append)
 return {
   Code = Code,
   NomsuCode = NomsuCode,

code_obj.moon

@@ -255,5 +255,6 @@ class NomsuCode extends Code
     __len: Code.__len
 
 Code.__base.add_1_joined_with = assert Code.__base.concat_append
+Code.__base.add = assert Code.__base.append
 
 return {:Code, :NomsuCode, :LuaCode, :Source}

core/collections.nom

@@ -151,26 +151,25 @@ test:
     %t = {}
     set %t 's metatable to {__tostring:[%] -> "XXX"}
     assume ("\%t" == "XXX")
-(set %dict 's metatable to %metatable) compiles to (..)
+(set %dict 's metatable to %metatable) compiles to "\
-    Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
+    ..setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
 
-[% 's metatable, % 'metatable] all compile to (..)
+[% 's metatable, % 'metatable] all compile to "\
-    Lua value "getmetatable(\(% as lua expr))"
+    ..getmetatable(\(% as lua expr))"
 
 test:
     assume (({} with fallback % -> (% + 1)).10 == 11)
-(%dict with fallback %key -> %value) compiles to (..)
+(%dict with fallback %key -> %value) compiles to "\
-    Lua value "\
+    ..(function(d)
-        ..(function(d)
+        local mt = {}
-            local mt = {}
+        for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
-            for k,v in pairs(getmetatable(d) or {}) do mt[k] = v end
+        mt.__index = function(self, \(%key as lua expr))
-            mt.__index = function(self, \(%key as lua expr))
+            local value = \(%value as lua expr)
-                local value = \(%value as lua expr)
+            self[\(%key as lua expr)] = value
-                self[\(%key as lua expr)] = value
+            return value
-                return value
+        end
-            end
+        return setmetatable(d, mt)
-            return setmetatable(d, mt)
+    end)(\(%dict as lua expr))"
-        end)(\(%dict as lua expr))"
 
 # Sorting
 test:
@@ -182,7 +181,7 @@ test:
     %keys = {1:999, 2:0, 3:50}
     sort %x by % = %keys.%
     assume (%x == [2, 3, 1])
-(sort %items) compiles to (Lua "table.sort(\(%items as lua expr));")
+(sort %items) compiles to "table.sort(\(%items as lua expr));"
 [..]
     sort %items by %item = %key_expr, sort %items by %item -> %key_expr
 ..all parse as (..)

core/control_flow.nom

@@ -12,19 +12,16 @@ use "core/errors.nom"
 
 # No-Op
 test: do nothing
-(do nothing) compiles to (Lua "")
+(do nothing) compiles to ""
 
 # Conditionals
 test:
     if (no):
         barf "conditional fail"
-(if %condition %if_body) compiles to:
+(if %condition %if_body) compiles to "\
-    %lua = (Lua "if ")
+    ..if \(%condition as lua expr) then
-    %lua::append (%condition as lua expr)
+        \(%if_body as lua statements)
-    %lua::append " then\n    "
+    end"
-    %lua::append (%if_body as lua statements)
-    %lua::append "\nend"
-    return %lua
 
 test:
     unless (yes):
@@ -32,15 +29,12 @@ test:
 (unless %condition %unless_body) parses as (if (not %condition) %unless_body)
 [..]
     if %condition %if_body else %else_body, unless %condition %else_body else %if_body
-..all compile to:
+..all compile to "\
-    %lua = (Lua "if ")
+    ..if \(%condition as lua expr) then
-    %lua::append (%condition as lua expr)
+        \(%if_body as lua statements)
-    %lua::append " then\n    "
+    else
-    %lua::append (%if_body as lua statements)
+        \(%else_body as lua statements)
-    %lua::append "\nelse\n    "
+    end"
-    %lua::append (%else_body as lua statements)
-    %lua::append "\nend"
-    return %lua
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -60,7 +54,7 @@ test:
         equivalent of a conditional expression: (cond and if_true or if_false)
     if {Text:yes, List:yes, Dict:yes, Number:yes}.(%when_true_expr.type):
         return (..)
-            Lua value "\
+            Lua "\
                 ..(\(%condition as lua expr) and \(%when_true_expr as lua expr) or \(..)
                     %when_false_expr as lua expr
                 ..)"
@@ -69,7 +63,7 @@ test:
             doesn't have a proper ternary operator!)
             To see why this is necessary consider: (random()<.5 and false or 99)
         return (..)
-            Lua value "\
+            Lua "\
                 ..((function()
                     if \(%condition as lua expr) then
                         return \(%when_true_expr as lua expr)
@@ -91,17 +85,15 @@ test:
     %i -= 1
     unless (%i == 0): go to (Loop)
     assume (%i == 0)
-[=== %label ===, --- %label ---, *** %label ***] all compile to (..)
+[=== %label ===, --- %label ---, *** %label ***] all compile to "\
-    Lua "\
+    ..::label_\(..)
-        ..::label_\(..)
+        (%label.stub if (%label.type == "Action") else %label) as lua identifier
-            (%label.stub if (%label.type == "Action") else %label) as lua identifier
+    ..::"
-        ..::"
 
-(go to %label) compiles to (..)
+(go to %label) compiles to "\
-    Lua "\
+    ..goto label_\(..)
-        ..goto label_\(..)
+        (%label.stub if (%label.type == "Action") else %label) as lua identifier
-            (%label.stub if (%label.type == "Action") else %label) as lua identifier
+    .."
-        .."
 
 # Basic loop control
 (stop %var) compiles to:
@@ -114,10 +106,10 @@ test:
         return (..)
             Lua "goto continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)"
     ..else: return (Lua "goto continue")
-[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to (..)
+[===stop %var ===, ---stop %var ---, ***stop %var ***] all compile to "\
-    Lua "::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
+    ..::stop_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
-[===next %var ===, ---next %var ---, ***next %var ***] all compile to (..)
+[===next %var ===, ---next %var ---, ***next %var ***] all compile to "\
-    Lua "::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
+    ..::continue_\((%var.stub if (%var.type == "action") else %var) as lua identifier)::"
 
 # While loops
 test:
@@ -139,8 +131,8 @@ test:
         barf "Failed to 'do next repeat'"
     
     assume (%x == 30)
-(do next repeat) compiles to (Lua "goto continue_repeat")
+(do next repeat) compiles to "goto continue_repeat"
-(stop repeating) compiles to (Lua "goto stop_repeat")
+(stop repeating) compiles to "goto stop_repeat"
 (repeat while %condition %body) compiles to:
     %lua = (..)
         Lua "\
@@ -155,8 +147,7 @@ test:
     if (%body has subtree \(stop repeating)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope of 'stop repeating' label\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua "\
-        %lua::append "\
             ..
                 ::stop_repeat::
             end -- end of 'stop repeating' label scope"
@@ -183,8 +174,7 @@ test:
     if (%body has subtree \(stop repeating)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope of 'stop repeating' label\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua "\
-        %lua::append "\
             ..
                 ::stop_repeat::
             end -- end of 'stop repeating' label scope"
@@ -226,20 +216,17 @@ test:
                 %step as lua expr
             .. do"
     
-    %lua::append "\n    "
+    %lua::append "\n    " (%body as lua statements)
-    %lua::append (%body as lua statements)
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
+        %lua::append "\n    " (what (===next %var ===) compiles to)
-        %lua::append (what (===next %var ===) compiles to)
     
     %lua::append "\nend --numeric for-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua "\n    "
-        %lua::append "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -273,15 +260,13 @@ test:
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
+        %lua::append "\n    " (what (===next %var ===) compiles to)
-        %lua::append (what (===next %var ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua "\n    "
-        %lua::append "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -296,15 +281,13 @@ test:
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %var)):
-        %lua::append "\n    "
+        %lua::append "\n    " (what (===next %var ===) compiles to)
-        %lua::append (what (===next %var ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     if (%body has subtree \(stop %var)):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for-loop\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua "\n    "
-        %lua::append "\n    "
         %lua::append (what (===stop %var ===) compiles to)
         %lua::append "\nend -- end of scope for stopping for-loop"
     
@@ -335,34 +318,27 @@ test:
                 %iterable as lua expr
             ..) do"
     
-    %lua::append "\n    "
+    %lua::append "\n    " (%body as lua statements)
-    %lua::append (%body as lua statements)
     if (%body has subtree \(do next)):
         %lua::append "\n    ::continue::"
     if (%body has subtree \(do next %key)):
-        %lua::append "\n    "
+        %lua::append "\n    " (what (===next %key ===) compiles to)
-        %lua::append (what (===next %key ===) compiles to)
     
     if (%body has subtree \(do next %value)):
-        %lua::append "\n    "
+        %lua::append "\n    " (what (===next %value ===) compiles to)
-        %lua::append (what (===next %value ===) compiles to)
     
     %lua::append "\nend --foreach-loop"
     %stop_labels = (Lua "")
     if (%body has subtree \(stop %key)):
-        %stop_labels::append "\n"
+        %stop_labels::append "\n" (what (===stop %key ===) compiles to)
-        %stop_labels::append (what (===stop %key ===) compiles to)
     
     if (%body has subtree \(stop %value)):
-        %stop_labels::append "\n"
+        %stop_labels::append "\n" (what (===stop %value ===) compiles to)
-        %stop_labels::append (what (===stop %value ===) compiles to)
     
     if ((size of "\%stop_labels") > 0):
         %inner_lua = %lua
         %lua = (Lua "do -- scope for stopping for % = % loop\n    ")
-        %lua::append %inner_lua
+        %lua::append %inner_lua %stop_labels "\nend"
-        %lua::append %stop_labels
-        %lua::append "\nend"
     
     return %lua
 
@@ -411,19 +387,16 @@ test:
                     ..need a conditional block around it. Otherwise, make sure the 'else' \
                     ..block comes last."
             
-            %code::append "\nelse\n    "
+            %code::append "\nelse\n    " (%action as lua statements)
-            %code::append (%action as lua statements)
             %else_allowed = (no)
         ..else:
-            %code::append %clause
+            %code::append %clause " "
-            %code::append " "
             for %i in 1 to ((size of %line) - 1):
                 if (%i > 1):
                     %code::append " or "
                 %code::append (%line.%i as lua expr)
             
-            %code::append " then\n    "
+            %code::append " then\n    " (%action as lua statements)
-            %code::append (%action as lua statements)
             %clause = "\nelseif"
     
     if ((size of "\%code") == 0):
@@ -472,42 +445,34 @@ test:
                     ..need a conditional block around it. Otherwise, make sure the 'else' \
                     ..block comes last."
             
-            %code::append "\nelse\n    "
+            %code::append "\nelse\n    " (%action as lua statements)
-            %code::append (%action as lua statements)
             %else_allowed = (no)
         ..else:
-            %code::append %clause
+            %code::append %clause " "
-            %code::append " "
             for %i in 1 to ((size of %line) - 1):
                 if (%i > 1):
                     %code::append " or "
-                %code::append "\(mangle "branch value") == "
+                %code::append "\(mangle "branch value") == " (%line.%i as lua expr)
-                %code::append (%line.%i as lua expr)
             
-            %code::append " then\n    "
+            %code::append " then\n    " (%action as lua statements)
-            %code::append (%action as lua statements)
             %clause = "\nelseif"
     
     if ((size of "\%code") == 0):
         compile error at %body "'if' block has an empty body."
         ..hint "This means nothing would happen, so the 'if' block should be deleted."
     %code::append "\nend --when"
-    %lua = (..)
+    return (..)
         Lua "\
             ..do --if % is...
-                local \(mangle "branch value") = "
+                local \(mangle "branch value") = \(%branch_value as lua expr)
-    %lua::append (%branch_value as lua expr)
+                \%code
-    %lua::append "\n    "
+            end -- if % is..."
-    %lua::append %code
-    %lua::append "\nend --if % is..."
-    return %lua
 
 # Do/finally
-(do %action) compiles to:
+(do %action) compiles to "\
-    %lua = (Lua "do\n    ")
+    ..do
-    %lua::append (%action as lua statements)
+        \(%action as lua statements)
-    %lua::append "\nend -- do"
+    end -- do"
-    return %lua
 
 test:
     %d = {}
@@ -519,29 +484,24 @@ test:
     assume (%d.x == "good")
 (do %action then always %final_action) compiles to:
     define mangler
-    %lua = (..)
+    return (..)
         Lua "\
             ..do
                 local \(mangle "fell_through") = false
-                local \(mangle "ok"), \(mangle "ret") = pcall(function()"
+                local \(mangle "ok"), \(mangle "ret") = pcall(function()
-    %lua::append "\n        "
+                    \(%action as lua statements)
-    %lua::append (%action as lua statements)
+                    \(mangle "fell_through") = true
-    %lua::append "\
+                end)
-        ..        \(mangle "fell_through") = true
+                \(%final_action as lua statements)
-            end)"
+                if not \(mangle "ok") then error(ret, 0) end
-    %lua::append "\n    "
+                if not \(mangle "fell_through") then return ret end
-    %lua::append (%final_action as lua statements)
+            end"
-    %lua::append "\
-        ..    if not \(mangle "ok") then error(ret, 0) end
-            if not \(mangle "fell_through") then return ret end
-        end"
-    return %lua
 
 test:
     assume ((result of (: return 99)) == 99)
 
 # Inline thunk:
-(result of %body) compiles to (Lua value "\(what ([] -> %body) compiles to)()")
+(result of %body) compiles to "\(what ([] -> %body) compiles to)()"
 
 test:
     %t = [1, [2, [[3], 4], 5, [[[6]]]]]
@@ -564,9 +524,8 @@ test:
                 ..do
                     local \(mangle "stack \(%var.1)") = List{\(%structure as lua expr)}
                     while #\(mangle "stack \(%var.1)") > 0 do
-                        \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)"
+                        \(%var as lua expr) = table.remove(\(mangle "stack \(%var.1)"), 1)
-        %lua::append "\n        "
+                        \(%body as lua statements)"
-        %lua::append (%body as lua statements)
         if (%body has subtree \(do next)):
             %lua::append "\n        ::continue::"
         if (%body has subtree \(do next %var)):

core/coroutines.nom

@@ -16,16 +16,13 @@ test:
     
     for % in coroutine %co: %nums::add %
     assume (%nums == [4, 5, 6, 6, 6]) or barf "Coroutine iteration failed"
-[coroutine %body, generator %body] all compile to (..)
+[coroutine %body, generator %body] all compile to "\
-    Lua value "\
+    ..(function()
-        ..(function()
+        \(%body as lua statements)
-            \(%body as lua statements)
+    end)"
-        end)"
 
-(->) compiles to (Lua value "coroutine.yield(true)")
+(-> %) compiles to "coroutine.yield(true, \((% as lua expr) if % else "nil"))"
-(-> %) compiles to (Lua value "coroutine.yield(true, \(% as lua expr))")
+(for % in coroutine %co %body) compiles to "\
-(for % in coroutine %co %body) compiles to (..)
+    ..for _junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
-    Lua "\
+        \(%body as lua statements)
-        ..for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
+    end"
-            \(%body as lua statements)
-        end"

core/errors.nom

@@ -6,11 +6,11 @@ use "core/metaprogramming.nom"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-(barf %msg) compiles to (Lua "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);")
+(barf %msg) compiles to "error(\(=lua "\%msg and \(%msg as lua expr) or 'nil'"), 0);"
-(compile error at %tree %msg) compiles to (..)
+(compile error at %tree %msg) compiles to "\
-    Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
+    ..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr))"
-(compile error at %tree %msg hint %hint) compiles to (..)
+(compile error at %tree %msg hint %hint) compiles to "\
-    Lua "nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
+    ..nomsu:compile_error(\(%tree as lua expr), \(%msg as lua expr), \(%hint as lua expr))"
 
 (assume %condition) compiles to:
     lua> "\
@@ -36,11 +36,10 @@ use "core/metaprogramming.nom"
                 end
             end"
 
-(assume %condition or barf %message) compiles to (..)
+(assume %condition or barf %message) compiles to "\
-    Lua "\
+    ..if not \(%condition as lua expr) then
-        ..if not \(%condition as lua expr) then
+        error(\(%message as lua expr), 0)
-            error(\(%message as lua expr), 0)
+    end"
-        end"
 
 test:
     try (barf) and if it succeeds: barf "try failed."
@@ -59,29 +58,28 @@ test:
 [..]
     try %action and if it succeeds %success or if it barfs %msg %fallback
     try %action and if it barfs %msg %fallback or if it succeeds %success
-..all compile to (..)
+..all compile to "\
-    Lua "\
+    ..do
-        ..do
+        local fell_through = false
-            local fell_through = false
+        local err, erred = nil, false
-            local err, erred = nil, false
+        local ok, ret = xpcall(function()
-            local ok, ret = xpcall(function()
+            \(%action as lua statements)
-                \(%action as lua statements)
+            fell_through = true
-                fell_through = true
+        end, function(\(=lua "\%fallback and \(%msg as lua expr) or ''"))
-            end, function(\(=lua "\%fallback and \(%msg as lua expr) or ''"))
+            local ok, ret = pcall(function()
-                local ok, ret = pcall(function()
+                \((=lua "\%fallback or \%msg") as lua statements)
-                    \((=lua "\%fallback or \%msg") as lua statements)
-                end)
-                if not ok then err, erred = ret, true end
             end)
-            if ok then
+            if not ok then err, erred = ret, true end
-                \(%success as lua statements)
+        end)
-                if not fell_through then
+        if ok then
-                    return ret
+            \(%success as lua statements)
-                end
+            if not fell_through then
-            elseif erred then
+                return ret
-                error(err, 0)
             end
-        end"
+        elseif erred then
+            error(err, 0)
+        end
+    end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

core/io.nom

@@ -17,9 +17,9 @@ use "core/metaprogramming.nom"
 (ask %prompt) compiles to:
     lua> "\
         ..if \%prompt.type == "Text" then
-            return LuaCode.Value(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
+            return LuaCode(tree.source, "(io.write(", \(%prompt as lua expr), ") and io.read())");
         else
-            return LuaCode.Value(tree.source, "(io.write(tostring(", \(..)
+            return LuaCode(tree.source, "(io.write(tostring(", \(..)
             %prompt as lua expr
         .., ")) and io.read())");
         end"

core/math.nom

@@ -16,18 +16,18 @@ test:
         ..math constants failed"
     %nan = (NaN)
     assume (%nan != %nan) or barf "NaN failed"
-[infinity, inf] all compile to (Lua value "math.huge")
+[infinity, inf] all compile to "math.huge"
-[not a number, NaN, nan] all compile to (Lua value "(0/0)")
+[not a number, NaN, nan] all compile to "(0/0)"
-[pi, Pi, PI] all compile to (Lua value "math.pi")
+[pi, Pi, PI] all compile to "math.pi"
-[tau, Tau, TAU] all compile to (Lua value "(2*math.pi)")
+[tau, Tau, TAU] all compile to "(2*math.pi)"
-(golden ratio) compiles to (Lua value "((1+math.sqrt(5))/2)")
+(golden ratio) compiles to "((1+math.sqrt(5))/2)"
-(e) compiles to (Lua value "math.exp(1)")
+(e) compiles to "math.exp(1)"
 
 # Functions:
 test:
     assume (("5" as a number) == 5)
-[% as a number, % as number] all compile to (..)
+((% as a number)'s meaning) = ((tonumber %)'s meaning)
-    Lua value "tonumber(\(% as lua expr))"
+((% as number)'s meaning) = ((tonumber %)'s meaning)
 
 test:
     assume (..)
@@ -37,40 +37,40 @@ test:
             hyperbolic tangent 5, e^ 5, ln 5, log base 2 of 5, floor 5, ceiling 5, round 5
     ..or barf "math functions failed"
 [absolute value %, | % |, abs %] all compile to (..)
-    Lua value "math.abs(\(% as lua expr))"
+    "math.abs(\(% as lua expr))"
 
 [square root %, square root of %, √ %, sqrt %] all compile to (..)
-    Lua value "math.sqrt(\(% as lua expr))"
+    "math.sqrt(\(% as lua expr))"
 
-[sine %, sin %] all compile to (Lua value "math.sin(\(% as lua expr))")
+[sine %, sin %] all compile to "math.sin(\(% as lua expr))"
-[cosine %, cos %] all compile to (Lua value "math.cos(\(% as lua expr))")
+[cosine %, cos %] all compile to "math.cos(\(% as lua expr))"
-[tangent %, tan %] all compile to (Lua value "math.tan(\(% as lua expr))")
+[tangent %, tan %] all compile to "math.tan(\(% as lua expr))"
-[arc sine %, asin %] all compile to (Lua value "math.asin(\(% as lua expr))")
+[arc sine %, asin %] all compile to "math.asin(\(% as lua expr))"
-[arc cosine %, acos %] all compile to (Lua value "math.acos(\(% as lua expr))")
+[arc cosine %, acos %] all compile to "math.acos(\(% as lua expr))"
-[arc tangent %, atan %] all compile to (Lua value "math.atan(\(% as lua expr))")
+[arc tangent %, atan %] all compile to "math.atan(\(% as lua expr))"
 [arc tangent %y / %x, atan2 %y %x] all compile to (..)
-    Lua value "math.atan2(\(%y as lua expr), \(%x as lua expr))"
+    "math.atan2(\(%y as lua expr), \(%x as lua expr))"
 
 [hyperbolic sine %, sinh %] all compile to (..)
-    Lua value "math.sinh(\(% as lua expr))"
+    "math.sinh(\(% as lua expr))"
 
 [hyperbolic cosine %, cosh %] all compile to (..)
-    Lua value "math.cosh(\(% as lua expr))"
+    "math.cosh(\(% as lua expr))"
 
 [hyperbolic tangent %, tanh %] all compile to (..)
-    Lua value "math.tanh(\(% as lua expr))"
+    "math.tanh(\(% as lua expr))"
 
-[e^ %, exp %] all compile to (Lua value "math.exp(\(% as lua expr))")
+[e^ %, exp %] all compile to "math.exp(\(% as lua expr))"
 [natural log %, ln %, log %] all compile to (..)
-    Lua value "math.log(\(% as lua expr))"
+    "math.log(\(% as lua expr))"
 
 [log % base %base, log base %base of %] all compile to (..)
-    Lua value "math.log(\(% as lua expr), \(%base as lua expr))"
+    "math.log(\(% as lua expr), \(%base as lua expr))"
 
-(floor %) compiles to (Lua value "math.floor(\(% as lua expr))")
+(floor %) compiles to "math.floor(\(% as lua expr))"
-[ceiling %, ceil %] all compile to (Lua value "math.ceil(\(% as lua expr))")
+[ceiling %, ceil %] all compile to "math.ceil(\(% as lua expr))"
 [round %, % rounded] all compile to (..)
-    Lua value "math.floor(\(% as lua expr) + .5)"
+    "math.floor(\(% as lua expr) + .5)"
 
 test:
     assume ((463 to the nearest 100) == 500) or barf "rounding failed"
@@ -86,8 +86,11 @@ externally [all of %items, all %items] all mean:
 [all of %items, all %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
+    if ((size of %items) == 0): return (Lua "true")
-    return (Lua value "(\(%clauses::joined with " and "))")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " and "
+    %lua::append ")"
+    return %lua
 [not all of %items, not all %items] all parse as (not (all of %items))
 
 externally [any of %items, any %items] all mean:
@@ -97,8 +100,11 @@ externally [any of %items, any %items] all mean:
 [any of %items, any %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
+    if ((size of %items) == 0): return (Lua "false")
-    return (Lua value "(\(%clauses::joined with " or "))")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " or "
+    %lua::append ")"
+    return %lua
 [none of %items, none %items] all parse as (not (any of %items))
 
 # Sum/product
@@ -109,8 +115,11 @@ externally [sum of %items, sum %items] all mean:
 [sum of %items, sum %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
+    if ((size of %items) == 0): return (Lua "0")
-    return (Lua value "(\(%clauses::joined with " + "))")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " + "
+    %lua::append ")"
+    return %lua
 
 externally [product of %items, product %items] all mean:
     %prod = 1
@@ -119,8 +128,11 @@ externally [product of %items, product %items] all mean:
 [product of %items, product %items] all compile to:
     unless (%items.type is "List"):
         return %tree
-    %clauses = (((% as lua expr)::text) for % in %items)
+    if ((size of %items) == 0): return (Lua "1")
-    return (Lua value "(\(%clauses::joined with " * "))")
+    %lua = (Lua "(")
+    %lua::add ((% as lua expr) for % in %items) joined with " * "
+    %lua::append ")"
+    return %lua
 
 externally [avg of %items, average of %items] all mean (..)
     (sum of %items) / (size of %items)
@@ -212,12 +224,12 @@ externally (seed random with %) means:
         for i=1,20 do math.random(); end"
 
 (seed random) parses as (seed random with (=lua "os.time()"))
-[random number, random, rand] all compile to (Lua value "math.random()")
+[random number, random, rand] all compile to "math.random()"
 [random int %n, random integer %n, randint %n] all compile to (..)
-    Lua value "math.random(\(%n as lua expr))"
+    "math.random(\(%n as lua expr))"
 
 [random from %low to %high, random number from %low to %high, rand %low %high] all \
-..compile to (Lua value "math.random(\(%low as lua expr), \(%high as lua expr))")
+..compile to "math.random(\(%low as lua expr), \(%high as lua expr))"
 
 externally [..]
     random choice from %elements, random choice %elements, random %elements

core/metaprogramming.nom

@@ -71,9 +71,8 @@ lua> "\
         if \%body.type == "Text" then
             \%body = SyntaxTree{source=\%body.source, type="Action", "Lua", \%body}
         end
-        local lua = LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
+        return LuaCode(tree.source, "compile.action[", \%action.stub:as_lua(),
             "] = ", \(what (%args -> %body) compiles to))
-        return lua
     end"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -332,7 +331,7 @@ test:
                 ..one
                 "two""
         ..== "\"one\\n\\\"two\\\"\""
-(quote %s) compiles to (Lua "tostring(\(%s as lua expr)):as_lua()")
+(quote %s) compiles to "tostring(\(%s as lua expr)):as_lua()"
 
 test:
     assume (lua type of {}) == "table"

core/operators.nom

@@ -11,15 +11,14 @@ test:
     assume (all [1 < 2, 2 > 1, 1 <= 2, 2 >= 1, 1 == 1, 1 != 2])
 
 # Comparison Operators
-(%x < %y) compiles to (Lua value "(\(%x as lua expr) < \(%y as lua expr))")
+(%x < %y) compiles to "(\(%x as lua expr) < \(%y as lua expr))"
-(%x > %y) compiles to (Lua value "(\(%x as lua expr) > \(%y as lua expr))")
+(%x > %y) compiles to "(\(%x as lua expr) > \(%y as lua expr))"
-(%x <= %y) compiles to (Lua value "(\(%x as lua expr) <= \(%y as lua expr))")
+(%x <= %y) compiles to "(\(%x as lua expr) <= \(%y as lua expr))"
-(%x >= %y) compiles to (Lua value "(\(%x as lua expr) >= \(%y as lua expr))")
+(%x >= %y) compiles to "(\(%x as lua expr) >= \(%y as lua expr))"
-[%a is %b, %a == %b] all compile to (..)
+[%a is %b, %a == %b] all compile to "(\(%a as lua expr) == \(%b as lua expr))"
-    Lua value "(\(%a as lua expr) == \(%b as lua expr))"
 
-[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to (..)
+[%a isn't %b, %a is not %b, %a not= %b, %a != %b] all compile to "\
-    Lua value "(\(%a as lua expr) ~= \(%b as lua expr))"
+    ..(\(%a as lua expr) ~= \(%b as lua expr))"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -45,6 +44,7 @@ test:
     assume ((%y == 10) and (%x == 20)) or barf "swapping vars failed."
 
 # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
+# TODO: deprecate?
 (set %assignments) compiles to:
     assume (%assignments.type is "Dict") or barf "\
         ..Expected a Dict for the assignments part of '<- %' statement, not \%assignments"
@@ -143,7 +143,7 @@ test:
 test:
     assume ((5 wrapped around 2) == 1) or barf "mod not working"
 [%x wrapped around %y, %x mod %y] all compile to (..)
-    Lua value "((\(%x as lua expr)) % (\(%y as lua expr)))"
+    "((\(%x as lua expr)) % (\(%y as lua expr)))"
 
 # 3-part chained comparisons
 # (uses a lambda to avoid re-evaluating middle value, while still being an expression)
@@ -187,8 +187,8 @@ test:
     assume (((no) and (barfer)) == (no))
     assume ((no) or (yes))
     assume ((yes) or (barfer))
-(%x and %y) compiles to (Lua value "(\(%x as lua expr) and \(%y as lua expr))")
+(%x and %y) compiles to "(\(%x as lua expr) and \(%y as lua expr))"
-(%x or %y) compiles to (Lua value "(\(%x as lua expr) or \(%y as lua expr))")
+(%x or %y) compiles to "(\(%x as lua expr) or \(%y as lua expr))"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -204,49 +204,39 @@ test:
 
 # Lua 5.3 introduced bit operators like | and &. Use them when possible, otherwise
     fall back to bit.bor(), bit.band(), etc.
-%use_bitops = ((is jit) or ((Lua version) == "Lua 5.2"))
+lua> "if \((is jit) or ((Lua version) == "Lua 5.2")) then"
-[NOT %, ~ %] all compile to (..)
+[NOT %, ~ %] all compile to "bit.bnot(\(% as lua expr))"
-    Lua value (..)
+[%x OR %y, %x | %y] all compile to "bit.bor(\(%x as lua expr), \(%y as lua expr))"
-        (%use_bitops and "bit.bnot(\(% as lua expr))") or "~(\(% as lua expr))"
+[%x XOR %y, %x ~ %y] all compile to "bit.bxor(\(%x as lua expr), \(%y as lua expr))"
-
+[%x AND %y, %x & %y] all compile to "bit.band(\(%x as lua expr), \(%y as lua expr))"
-[%a OR %b, %a | %b] all compile to (..)
+[%x LSHIFT %shift, %x << %shift] all compile to "\
-    Lua value (..)
+    ..bit.lshift(\(%x as lua expr), \(%shift as lua expr))"
-        (%use_bitops and "bit.bor(\(%a as lua expr), \(%b as lua expr))") or "\
+[%x RSHIFT %shift, %x >> %shift] all compile to "\
-            ..(\(%a as lua expr) | \(%b as lua expr))"
+    ..bit.rshift(\(%x as lua expr), \(%shift as lua expr))"
-
+lua> "else"
-[%a XOR %b, %a ~ %b] all compile to (..)
+[NOT %, ~ %] all compile to "~(\(% as lua expr))"
-    Lua value (..)
+[%x OR %y, %x | %y] all compile to "(\(%x as lua expr) | \(%y as lua expr))"
-        (%use_bitops and "bit.bxor(\(%a as lua expr), \(%b as lua expr))") or "\
+[%x XOR %y, %x ~ %y] all compile to "(\(%x as lua expr) ~ \(%y as lua expr))"
-            ..(\(%a as lua expr) ~ \(%b as lua expr))"
+[%x AND %y, %x & %y] all compile to "(\(%x as lua expr) & \(%y as lua expr))"
-
+[%x LSHIFT %shift, %x << %shift] all compile to "\
-[%a AND %b, %a & %b] all compile to (..)
+    ..(\(%x as lua expr) << \(%shift as lua expr))"
-    Lua value (..)
+[%x RSHIFT %shift, %x >> %shift] all compile to "\
-        (%use_bitops and "bit.band(\(%a as lua expr), \(%b as lua expr))") or "\
+    ..(\(%x as lua expr) >> \(%shift as lua expr))"
-            ..(\(%a as lua expr) & \(%b as lua expr))"
+lua> "end"
-
-[%x LSHIFT %shift, %x << %shift] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.lshift(\(%x as lua expr), \(%shift as lua expr))") or "\
-            ..(\(%x as lua expr) << \(%shift as lua expr))"
-
-[%x RSHIFT %shift, %x >> %shift] all compile to (..)
-    Lua value (..)
-        (%use_bitops and "bit.rshift(\(%x as lua expr), \(%shift as lua expr))") or "\
-            ..(\(%x as lua expr) >> \(%shift as lua expr))"
 
 # Unary operators
 test:
     assume ((- 5) == -5)
     assume ((not (yes)) == (no))
-(- %) compiles to (Lua value "(- \(% as lua expr))")
+(- %) compiles to "(- \(% as lua expr))"
-(not %) compiles to (Lua value "(not \(% as lua expr))")
+(not %) compiles to "(not \(% as lua expr))"
 
 test:
     assume ((size of [1, 2, 3]) == 3)
 [size of %list, size of %list, size of %list, size of %list] all compile to (..)
-    Lua value "(#\(%list as lua expr))"
+    "(#\(%list as lua expr))"
 
-(%list is empty) compiles to (Lua value "(#\(%list as lua expr) == 0)")
+(%list is empty) compiles to "(#\(%list as lua expr) == 0)"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

core/text.nom

@@ -29,17 +29,19 @@ test:
     %こんにちは = "こんにちは"
     (% と言う) とは "\(%)世界"
     assume (%こんにちは と言う) == "こんにちは世界"
-(%expr for %match in %text matching %patt) compiles to (..)
+(%expr for %match in %text matching %patt) compiles to:
-    Lua value "\
+    define mangler
-        ..(function()
+    return (..)
-            local ret = _List{}
+        Lua "\
-            for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
+            ..(function()
-            %patt as lua expr
+                local \(mangle "comprehension") = _List{}
-        ..) do
+                for \(%match as lua expr) in (\(%text as lua expr)):gmatch(\(..)
-                ret[#ret+1] = \(%expr as lua statements)
+                %patt as lua expr
-            end
+            ..) do
-            return ret
+                    \(mangle "comprehension")[#\(mangle "comprehension")+1] = \(%expr as lua statements)
-        end)()"
+                end
+                return \(mangle "comprehension")
+            end)()"
 
 test:
     assume "\n" == (newline)

files.lua

@@ -256,7 +256,7 @@ Files.get_line = function(str, line_no)
   if not (stop) then
     return 
   end
-  return str:sub(start, stop - 2)
+  return (str:sub(start, stop - 2))
 end
 local get_lines = re.compile([[    lines <- {| line (%nl line)* |}
     line <- {[^%nl]*}

files.moon

@@ -152,7 +152,7 @@ Files.get_line = (str, line_no)->
     return unless start
     stop = line_starts[line_no+1]
     return unless stop
-    return str\sub(start, stop - 2)
+    return (str\sub(start, stop - 2))
 
 get_lines = re.compile([[
     lines <- {| line (%nl line)* |}

lib/consolecolor.nom

@@ -15,9 +15,9 @@ test:
 for %name = %colornum in %colors:
     %colornum = "\%colornum"
     #(=lua "COMPILE_ACTIONS").%name = (..)
-        [%nomsu, %tree] -> (Lua value "'\\027[\(%colornum)m'")
+        [%nomsu, %tree] -> (Lua "'\\027[\(%colornum)m'")
     %compile.action.%name = (..)
         [%nomsu, %tree, %text] ->:
             if %text:
-                return (Lua value "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
+                return (Lua "('\\027[\(%colornum)m'..\(%text as lua expr)..'\\027[0m')")
-            ..else: return (Lua value "'\\027[\(%colornum)m'")
+            ..else: return (Lua "'\\027[\(%colornum)m'")

lib/os.nom

@@ -21,23 +21,21 @@ externally (read file %filename) means (=lua "Files.read(\%filename)")
 
 test:
     for file %f in "core": do nothing
-(for file %f in %path %body) compiles to (..)
+(for file %f in %path %body) compiles to "\
-    Lua "\
+    ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
-        ..for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
+        \(%body as lua statements)
-            \(%body as lua statements)
+        \(what (===next %f ===) compiles to)
-            \(what (===next %f ===) compiles to)
+    end
-        end
+    \(what (===stop %f ===) compiles to)"
-        \(what (===stop %f ===) compiles to)"
 
-(%expr for file %f in %path) compiles to (..)
+(%expr for file %f in %path) compiles to "\
-    Lua value "\
+    ..(function()
-        ..(function()
+        local ret = List{}
-            local ret = List{}
+        for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
-            for i,\(%f as lua expr) in Files.walk(\(%path as lua expr)) do
+            ret[#ret+1] = \(%expr as lua statements)
-                ret[#ret+1] = \(%expr as lua statements)
+        end
-            end
+        return ret
-            return ret
+    end)()"
-        end)()"
 
 externally [..]
     write to file %filename %text, to file %filename write %text

lib/version.nom

@@ -1,3 +1,3 @@
 #!/usr/bin/env nomsu -V4.8.10
 # This file sets the current library version.
-lua> "NOMSU_LIB_VERSION = 6"
+lua> "NOMSU_LIB_VERSION = 7"

nomsu_compiler.lua

@@ -50,13 +50,18 @@ compile_error = function(tree, err_msg, hint)
     title = "Compile error",
     error = err_msg,
     hint = hint,
-    source = tree:get_source_code(),
+    source = tree:get_source_file(),
     start = tree.source.start,
     stop = tree.source.stop,
     filename = tree.source.filename
   })
   return error(err_str, 0)
 end
+local tree_to_nomsu, tree_to_inline_nomsu
+do
+  local _obj_0 = require("nomsu_decompiler")
+  tree_to_nomsu, tree_to_inline_nomsu = _obj_0.tree_to_nomsu, _obj_0.tree_to_inline_nomsu
+end
 local math_expression = re.compile([[ (([*/^+-] / [0-9]+) " ")* [*/^+-] !. ]])
 local compile_math_expression
 compile_math_expression = function(compile, tree, ...)
@@ -125,9 +130,6 @@ local compile = setmetatable({
       end
       return operate_on_text(code)
     end,
-    ["Lua value"] = function(compile, tree, code)
-      return compile.action["Lua"](compile, tree, code)
-    end,
     ["lua >"] = function(compile, tree, code)
       if code.type ~= "Text" then
         return tree
@@ -159,7 +161,17 @@ local compile = setmetatable({
       return LuaCode(tree.source, "TESTS")
     end,
     ["test"] = function(compile, tree, body)
-      return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", body:as_lua())
+      if not (body.type == 'Block') then
+        compile_error(tree, "This should be a Block")
+      end
+      local test_nomsu = body:get_source_code():match(":[ ]*(.*)")
+      do
+        local indent = test_nomsu:match("\n([ ]*)")
+        if indent then
+          test_nomsu = test_nomsu:gsub("\n" .. indent, "\n")
+        end
+      end
+      return LuaCode(tree.source, "TESTS[" .. tostring(tostring(tree.source):as_lua()) .. "] = ", test_nomsu:as_lua())
     end,
     ["is jit"] = function(compile, tree, code)
       return LuaCode(tree.source, "jit")

nomsu_compiler.moon

@@ -30,11 +30,11 @@ pretty_error = require("pretty_errors")
 compile_error = (tree, err_msg, hint=nil)->
     err_str = pretty_error{
         title: "Compile error"
-        error:err_msg, hint:hint, source:tree\get_source_code!
+        error:err_msg, hint:hint, source:tree\get_source_file!
         start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename
     }
     error(err_str, 0)
-
+{:tree_to_nomsu, :tree_to_inline_nomsu} = require "nomsu_decompiler"
 
 -- This is a bit of a hack, but this code handles arbitrarily complex
 -- math expressions like 2*x + 3^2 without having to define a single
@@ -88,9 +88,6 @@ compile = setmetatable({
                 return lua
             return operate_on_text code
 
-        -- TODO: remove shim
-        ["Lua value"]: (compile, tree, code)-> compile.action["Lua"](compile, tree, code)
-
         ["lua >"]: (compile, tree, code)->
             if code.type != "Text"
                 return tree
@@ -116,8 +113,12 @@ compile = setmetatable({
 
         ["tests"]: (compile, tree)-> LuaCode(tree.source, "TESTS")
         ["test"]: (compile, tree, body)->
-            -- TODO: maybe go back to storing nomsu code instead of syntax tree
+            unless body.type == 'Block'
-            LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", body\as_lua!
+                compile_error(tree, "This should be a Block")
+            test_nomsu = body\get_source_code!\match(":[ ]*(.*)")
+            if indent = test_nomsu\match("\n([ ]*)")
+                test_nomsu = test_nomsu\gsub("\n"..indent, "\n")
+            LuaCode tree.source, "TESTS[#{tostring(tree.source)\as_lua!}] = ", test_nomsu\as_lua!
 
         ["is jit"]: (compile, tree, code)-> LuaCode(tree.source, "jit")
         ["Lua version"]: (compile, tree, code)-> LuaCode(tree.source, "_VERSION")

nomsu_environment.lua

@@ -164,7 +164,7 @@ local nomsu_environment = Importer({
               title = "Parse error",
               error = e.error,
               hint = e.hint,
-              source = e:get_source_code(),
+              source = e:get_source_file(),
               start = e.source.start,
               stop = e.source.stop,
               filename = e.source.filename
@@ -312,7 +312,7 @@ local nomsu_environment = Importer({
       title = "Compile error",
       error = err_msg,
       hint = hint,
-      source = tree:get_source_code(),
+      source = tree:get_source_file(),
       start = tree.source.start,
       stop = tree.source.stop,
       filename = tree.source.filename

nomsu_environment.moon

@@ -75,7 +75,7 @@ nomsu_environment = Importer{
         if num_errs > 0
             err_strings = [pretty_error{
                     title:"Parse error"
-                    error:e.error, hint:e.hint, source:e\get_source_code!
+                    error:e.error, hint:e.hint, source:e\get_source_file!
                     start:e.source.start, stop:e.source.stop, filename:e.source.filename
                 } for i, e in ipairs(errs) when i <= 3]
             if num_errs > #err_strings
@@ -170,7 +170,7 @@ nomsu_environment = Importer{
     compile_error_at: (tree, err_msg, hint=nil)->
         err_str = pretty_error{
             title: "Compile error"
-            error:err_msg, hint:hint, source:tree\get_source_code!
+            error:err_msg, hint:hint, source:tree\get_source_file!
             start:tree.source.start, stop:tree.source.stop, filename:tree.source.filename
         }
         error(err_str, 0)

syntax_tree.lua

@@ -83,9 +83,12 @@ do
       end
       return "SyntaxTree{" .. tostring(table.concat(bits, ", ")) .. "}"
     end,
-    get_source_code = function(self)
+    get_source_file = function(self)
       return self.__class.source_code_for_tree[self]
     end,
+    get_source_code = function(self)
+      return self.__class.source_code_for_tree[self]:sub(self.source.start, self.source.stop)
+    end,
     map = function(self, fn)
       local replacement = fn(self)
       if replacement == false then

syntax_tree.moon

@@ -45,7 +45,8 @@ class SyntaxTree
         f = Files.read(s.filename)
         return f
     })
-    get_source_code: => @@source_code_for_tree[@]
+    get_source_file: => @@source_code_for_tree[@]
+    get_source_code: => @@source_code_for_tree[@]\sub(@source.start, @source.stop)
     map: (fn)=>
         replacement = fn(@)
         if replacement == false then return nil