Some cleanup and fixes. Simplifying a lot of code, and extending the

flexibility of scoping. Redesigned Object system too.

core/control_flow.nom

@@ -359,51 +359,6 @@ immediately
                 end --when % = ?
         return %code
 
-# Try/except
-immediately
-    compile [..]
-        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
-    ..to
-        Lua ".."
-            do
-                local fell_through = false
-                local err, erred = nil, false
-                local ok, ret = xpcall(function()
-                    \(%action as lua statements)
-                    fell_through = true
-                end, function(\(%msg as lua expr))
-                    local ok, ret = pcall(function()
-                        \(%fallback as lua statements)
-                    end)
-                    if not ok then err, erred = ret, true end
-                end)
-                if ok then
-                    \(%success as lua statements)
-                    if not fell_through then
-                        return ret
-                    end
-                elseif erred then
-                    error(err, 0)
-                end
-            end
-immediately
-    parse [..]
-        try %action and if it succeeds %success or if it barfs %fallback
-        try %action and if it barfs %fallback or if it succeeds %success
-    ..as: try %action and if it succeeds %success or if it barfs (=lua "") %fallback
-immediately
-    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
-        try %action and if it succeeds: do nothing
-        ..or if it barfs %fallback
-    parse [try %action and if it barfs %msg %fallback] as
-        try %action and if it succeeds: do nothing
-        ..or if it barfs %msg %fallback
-    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
@@ -433,17 +388,7 @@ immediately
         declare locals in %body
         return
             Lua value ".."
-                ((function()
+                (function()
                     \%body
-                end)())
+                end)()
 
-# Coroutines:
-immediately
-    compile [values %body, coroutine %body, generator %body] to
-        Lua value ".."
-            (function()
-                \(%body as lua statements)
-            end)
-    compile [->] to: Lua "coroutine.yield(true);"
-    compile [-> %] to: Lua "coroutine.yield(true, \(% as lua expr));"
-    compile [-> %k = %v] to: Lua "coroutine.yield(\(%k as lua expr), \(%v as lua expr));"

core/coroutines.nom

@@ -0,0 +1,17 @@
+#
+    This file defines the code that creates and manipulates coroutines
+
+use "core/metaprogramming.nom"
+
+compile [coroutine %body, generator %body] to
+    Lua value ".."
+        (function()
+            \(%body as lua statements)
+        end)
+compile [->] to: Lua value "coroutine.yield(true)"
+compile [-> %] to: Lua value "coroutine.yield(true, \(% as lua expr))"
+compile [for % in coroutine %co %body] to
+    Lua ".."
+        for junk,\(% as lua expr) in coroutine.wrap(\(%co as lua expr)) do
+            \(%body as lua statements)
+        end

core/errors.nom

@@ -20,3 +20,49 @@ compile [assume %condition or barf %message] to
         if not \(%condition as lua expr) then
             error(\(%message as lua expr), 0);
         end
+
+# Try/except
+immediately
+    compile [..]
+        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
+    ..to
+        Lua ".."
+            do
+                local fell_through = false
+                local err, erred = nil, false
+                local ok, ret = xpcall(function()
+                    \(%action as lua statements)
+                    fell_through = true
+                end, function(\(%msg as lua expr))
+                    local ok, ret = pcall(function()
+                        \(%fallback as lua statements)
+                    end)
+                    if not ok then err, erred = ret, true end
+                end)
+                if ok then
+                    \(%success as lua statements)
+                    if not fell_through then
+                        return ret
+                    end
+                elseif erred then
+                    error(err, 0)
+                end
+            end
+immediately
+    parse [..]
+        try %action and if it succeeds %success or if it barfs %fallback
+        try %action and if it barfs %fallback or if it succeeds %success
+    ..as: try %action and if it succeeds %success or if it barfs (=lua "") %fallback
+immediately
+    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
+        try %action and if it succeeds: do nothing
+        ..or if it barfs %fallback
+    parse [try %action and if it barfs %msg %fallback] as
+        try %action and if it succeeds: do nothing
+        ..or if it barfs %msg %fallback
+    parse [try %action and if it succeeds %success] as
+        try %action and if it succeeds %success or if it barfs: do nothing

core/metaprogramming.nom

@@ -117,8 +117,12 @@ immediately
     action [%tree as lua return]
         =lua "nomsu:tree_to_lua(\%tree):as_statements('return ')"
 
-    action [%var as lua identifier]
+    action [%var as lua identifier, %var as lua id]
-        =lua "type(\%var) == 'string' and string.as_lua_id(\%var) or nomsu:tree_to_lua(\%var)"
+        lua> ".."
+            if type(\%var) == 'string' then return string.as_lua_id(\%var)
+            elseif \%var.type == 'Var' then return string.as_lua_id(\%var[1])
+            elseif \%var.type == 'Action' then return "A"..string.as_lua_id(\%var.stub)
+            end
     
 immediately
     compile [%tree with %t -> %replacement] to

core/operators.nom

@@ -40,7 +40,7 @@ immediately
 
 immediately
     # Simultaneous mutli-assignments like: x,y,z = 1,x,3;
-    compile [<- %assignments] to
+    compile [<- %assignments, assign %assignments] to
         assume (%assignments.type is "Dict") or barf ".."
             Expected a Dict for the assignments part of '<- %' statement, not \%assignments
         lua> ".."

core/scopes.nom

@@ -1,54 +1,30 @@
 use "core/metaprogramming.nom"
-use "core/text.nom"
 use "core/operators.nom"
 use "core/collections.nom"
 use "core/control_flow.nom"
 
-compile [using %definitions %body, using %definitions do %body] to
+compile [with local %locals %body, with local %locals do %body] to
-    %setup_lua <-
+    %body_lua <- (%body as lua statements)
-        Lua ".."
+    when %locals.type = ?
-            local fell_through = false
+        * "Dict"
-            local ok, ret = pcall(function()
+            %body_lua <-
-                \(%definitions as lua statements)
+                Lua ".."
-                fell_through = true
+                    \(=lua "A_assign_1(\%locals, \%locals)")
-            end)
+                    \%body_lua
-    %body_lua <-
+            declare locals
-        Lua ".."
+                (%.1 as lua id) for % in %locals
-            local fell_through = false
+            .. in %body_lua
-            local ok, ret = pcall(function()
+        * "List"
-                \(%body as lua statements)
+            declare locals
-                fell_through = true
+                (% as lua id) for % in %locals
-            end)
+            .. in %body_lua
-    remove free vars (declare locals in %setup_lua) from %body_lua
+        * "Var"
-    %lua <-
+        * "Action"
+            declare locals [%locals as lua id] in %body_lua
+        * else
+            barf "Unexpected local: \(%locals as nomsu)"
+    return
         Lua ".."
             do
-                local old_actions, old_compile_actions, old_arg_orders = ACTIONS, COMPILE_ACTIONS, ARG_ORDERS
-                ACTIONS = setmetatable({}, {__index=old_actions})
-                COMPILE_ACTIONS = setmetatable({}, {__index=old_compile_actions})
-                ARG_ORDERS = setmetatable({}, {__index=old_arg_orders})
-                \%setup_lua
-                if not ok then
-                    ACTIONS, COMPILE_ACTIONS, ARG_ORDERS = old_actions, old_compile_actions, old_arg_orders
-                    error(ret, 0)
-                end
-                if not fell_through then
-                    ACTIONS, COMPILE_ACTIONS, ARG_ORDERS = old_actions, old_compile_actions, old_arg_orders
-                    return ret
-                end
-                getmetatable(ACTIONS).__newindex = old_actions
-                getmetatable(COMPILE_ACTIONS).__newindex = old_compile_actions
-                getmetatable(ARG_ORDERS).__newindex = old_arg_orders
                 \%body_lua
-                ACTIONS, COMPILE_ACTIONS, ARG_ORDERS = old_actions, old_compile_actions, old_arg_orders
-                if not ok then
-                    error(ret, 0)
-                end
-                if not fell_through then
-                    return ret
-                end
             end
-    declare locals in %lua
-    return %lua
-
-parse [using %] as: using % (do nothing)

lib/object.nom

@@ -1,7 +1,5 @@
 use "core"
 
-# TODO: make codegen less verbose
-
 lua> "CLASSES = {}"
 
 immediately
@@ -11,50 +9,41 @@ action [new %classname %inst]
 immediately
     parse [new %classname] as: new %classname {}
 
-compile [as %instance %body] to
+immediately
-    Lua ".."
+    compile [call method %method] to: Lua value "self:\(%method as lua expr)"
-        do
+
-            local self = \(%instance as lua expr)
+parse [as %instance %body] as
-            local old_self = self.class:set_self(self)
+    result of
-            old_actions, ACTIONS = ACTIONS, self.class.ACTIONS
+        %old_self <- (me)
-            old_compile_actions, COMPILE_ACTIONS = COMPILE_ACTIONS, self.class.COMPILE_ACTIONS
+        (me) <- %instance
-            old_arg_orders, ARG_ORDERS = ARG_ORDERS, self.class.ARG_ORDERS
+        try
-            local fell_through = false
+            %body
-            local ok, ret = pcall(function()
+        ..and if it barfs %msg
-                \(%body as lua statements)
+            (me) <- %old_self
-                fell_through = true
+            barf %msg
-            end)
+        ..or if it succeeds
-            self.class:set_self(old_self)
+            (me) <- %old_self
-            ACTIONS = old_actions
+
-            COMPILE_ACTIONS = old_compile_actions
+compile [object %classname %class_body] to
-            ARG_ORDERS = old_arg_orders
+    %lua <-
-            if not ok then error(ret) end
+        Lua ".."
-            if not fell_through then return ret end
+            do
+                local class = {name=\(%classname as lua expr)}
+                setmetatable(class, {__tostring=function(cls) return cls.name end})
+                CLASSES[class.name] = class
+                class.__index = class
+                class.class = class
+
+    if: %class_body.type != "Block"
+        %class_body <- [%class_body]
+    for %statement in %class_body
+        assume: (%statement.type is "Action") and (%statement.stub is "action % %")
+        to %lua write "\n    class."
+        to %lua write (%statement as lua)
+    
+    to %lua write ".."
+            
+            class.__tostring = class["A"..string.as_lua_id("as text")]
         end
     
-parse [object %classname %class_body] as
+    return %lua
-    using
-        %cls <- {..}
-            name:%classname
-            ACTIONS:=lua "ACTIONS", COMPILE_ACTIONS:=lua "COMPILE_ACTIONS"
-            ARG_ORDERS:=lua "ARG_ORDERS"
-        (=lua "CLASSES").%classname <- %cls
-        lua> ".."
-            setmetatable(\%cls, {__tostring=function() return \%classname end})
-            local self = nil
-            \%cls.set_self = function(_, inst)
-                local old_self = self
-                self = inst
-                return old_self
-            end
-            \%cls.__index = \%cls
-            \%cls.class = \%cls
-        %class_body
-        run ".."
-            action [new \%classname %inst]
-                say "NEWING"
-                return: =lua "setmetatable(\\%inst, \\%cls)"
-        lua> ".."
-            if ACTIONS["as text"] then
-                \%cls.__tostring = ACTIONS["as text"]
-            end

nomsu.lua

@@ -1305,6 +1305,16 @@ do
       self.environment.LOADED = { }
       self.environment.AST = AST
       self.environment._ENV = self.environment
+      setmetatable(self.environment, {
+        __index = function(self, k)
+          do
+            local _self = rawget(self, "self")
+            if _self then
+              return _self[k]
+            end
+          end
+        end
+      })
       return self:initialize_core()
     end,
     __base = _base_0,

nomsu.moon

@@ -299,6 +299,10 @@ class NomsuCompiler
         @environment.LOADED = {}
         @environment.AST = AST
         @environment._ENV = @environment
+        setmetatable @environment,
+            __index: (k)=>
+                if _self = rawget(@, "self")
+                    return _self[k]
         @initialize_core!
     
     parse: (nomsu_code)=>

tests/collections.nom

@@ -1,5 +1,5 @@
 #..
-    Tests for the stuff defined in lib/control_flow.nom
+    Tests for the stuff defined in core/control_flow.nom
 
 use "core"
 

tests/control_flow.nom

@@ -1,5 +1,5 @@
 #
-    Tests for the stuff defined in lib/control_flow.nom
+    Tests for the stuff defined in core/control_flow.nom
 
 use "core"
 
@@ -193,15 +193,3 @@ assume
             return %n
     ..= 6
 
-#
-    %nums <- []
-    for % in
-        values
-            -> 4
-            -> 5
-            -> 6
-    ..
-        add % to %nums
-
-    assume (%nums = [4,5,6]) or barf "Coroutine iteration failed"
-

tests/math.nom

@@ -1,5 +1,5 @@
 #..
-    Tests for the stuff defined in lib/control_flow.nom
+    Tests for the stuff defined in core/control_flow.nom
 
 use "core"
 

tests/metaprogramming.nom

@@ -1,5 +1,5 @@
 #..
-    Tests for the stuff defined in lib/metaprogramming.nom
+    Tests for the stuff defined in core/metaprogramming.nom
 
 use "core"
 

tests/object.nom

@@ -1,3 +1,6 @@
+#
+    Tests for the object model defined in lib/object.nom
+
 use "core"
 use "lib/object.nom"
 

tests/operators.nom

@@ -1,5 +1,5 @@
 #..
-    Tests for the stuff defined in lib/operators.nom
+    Tests for the stuff defined in core/operators.nom
 
 use "core"
 

tests/scopes.nom

@@ -1,25 +1,16 @@
 use "core"
 
-using
+%x <- "outer"
-    %x <- 99
+with local %x
-..do
+    %x <- "inner"
-    assume: %x = 99
+    assume: %x = "inner"
+assume: %x = "outer"
 
-using
+action [foo] "outer foo"
-    action [foo]
+with local (foo)
-        return 99
+    action [foo] "inner foo"
+    assume: (foo) = "inner foo"
+assume: (foo) = "outer foo"
 
-..do
-    assume: (foo) = 99
-
-action [baz]
-    return "outer"
-
-#
-    do
-        local action [baz]
-            return "inner"
-        assume: (baz) = "inner"
-    assume: (baz) = "outer"
 
 say "Scopes test passed."

tests/text.nom

@@ -1,5 +1,5 @@
 #..
-    Tests for the stuff defined in lib/text.nom
+    Tests for the stuff defined in core/text.nom
 
 use "core"