Cleanup: removed "File" type trees (now just Block), overhauled

how_do_i.nom, added "result of %" macro, which allowed comprehensions to
be way more concisely defined. Moved len() operator into the nomsu
environment.

1 files changed, 58 insertions, 85 deletions

diff --git a/core/collections.nom b/core/collections.nom
index 97bc7ad..9086e23 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -36,16 +36,14 @@ immediately
         return (yes)
 
 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 ".."
-            ((\(%list as lua expr))[ \(%index as lua expr)] ~= nil)
+    parse [%list has key %index, %list has index %index] as
+        %list.%index != (nil)
 
-    # Note: it's important to have the space after "[" to prevent confusion if %index is a string
-    compile [..]
+    parse [..]
         %list doesn't have key %index, %list does not have key %index
         %list doesn't have index %index, %list does not have index %index
-    ..to: Lua value "((\(%list as lua expr))[ \(%index as lua expr)] == nil)"
+    ..as
+        %list.%index = (nil)
 
     compile [number of keys in %list] to
         Lua value "utils.size(\(%list as lua expr))"
@@ -61,90 +59,65 @@ immediately
 
 # List Comprehension
 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
-            Lua value ".."
-                (function()
-                    local comprehension = {};
-                    for i,\(%item as lua expr) in ipairs(\(%iterable as lua expr)) do
-                        comprehension[i] = \(%expression as lua expr);
-                    end
-                    return comprehension;
-                end)()
-    parse [%expression for all %iterable] as: %expression for % in %iterable
+    parse [%expression for %item in %iterable] as
+        result of
+            %comprehension <- []
+            for %i = %item in %iterable
+                %comprehension.%i <- %expression
+            return %comprehension
 
-    compile [..]
+    parse [%expression for all %iterable] as
+        %expression for % in %iterable
+
+    parse [..]
         %expression for %index from %start to %stop via %step
         %expression for %index from %start to %stop by %step
-    ..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
-            Lua value ".."
-                (function()
-                    local comprehension = {};
-                    for \(%index as lua expr)=\(%start as lua expr),\(%stop as lua expr),\(%step as lua expr) do
-                        comprehension[#comprehension+1] = \(%expression as lua expr);
-                    end
-                    return comprehension;
-                end)()
-    parse [%expression for all ] as: %expression for % in %iterable
-    parse [%expression for %var from %start to %stop] as: %expression for %var from %start to %stop via 1
+    ..as
+        result of
+            %comprehension <- []
+            for %index from %start to %stop via %step
+                add %expression to %comprehension
+            return %comprehension
+
+    parse [%expression for all %iterable] as
+        %expression for % in %iterable
+
+    parse [%expression for %var from %start to %stop] as
+        %expression for %var from %start to %stop via 1
+
     parse [..]
         %expression for all %start to %stop by %step
         %expression for all %start to %stop via %step
-    ..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
-        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 ".."
-            List comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%value.type)
-        return
-            Lua value ".."
-                (function()
-                    local comprehension = {};
-                    for \(%key as lua expr), \(%value as lua expr) in pairs(\(%iterable as lua expr)) do
-                        table.insert(comprehension, \(%expression as lua expr));
-                    end
-                    return comprehension;
-                end)()
-
-# Dict comprehensions
-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
-        return
-            Lua value ".."
-                (function()
-                    local comprehension = {};
-                    for i,\(%item as lua expr) in ipairs(\(%iterable as lua expr)) do
-                        comprehension[ \(%key as lua expr)] = \(%value as lua expr)
-                    end
-                    return comprehension;
-                end)()
-    parse [%key = %value for all %iterable] as: %key = %value for % in %iterable
-
-    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 ".."
-            Dict comprehension has the wrong type for the value loop variable. Expected Var, but got: \(%src_value.type)
-        # Note: it's important to have the space after "[" to prevent confusion if %key is a string
-        return
-            Lua value ".."
-                (function()
-                    local comprehension = {};
-                    for \(%src_key as lua expr), \(%src_value as lua expr) in pairs(\(%iterable as lua expr)) do
-                        comprehension[ \(%key as lua expr)] = \(%value as lua expr);
-                    end
-                    return comprehension;
-                end)()
+    ..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
+
+    parse [%expression for %key = %value in %iterable] as
+        result of
+            %comprehension <- []
+            for %key = %value in %iterable
+                add %expression to %comprehension
+            return %comprehension
+
+    # Dict comprehensions
+    parse [%key = %value for %item in %iterable] as
+        result of
+            %comprehension <- {}
+            for %item in %iterable
+                %comprehension.%key <- %value
+            return %comprehension
+
+    parse [%key = %value for all %iterable] as
+        %key = %value for % in %iterable
+
+    parse [%key = %value for %src_key = %src_value in %iterable] as
+        result of
+            %comprehension <- {}
+            for %src_key = %src_value in %iterable
+                %comprehension.%key <- %value
+            return %comprehension
 
 immediately
     action [%lists flattened]