Auto-formatted and auto-upgraded everything!

1 files changed, 94 insertions, 40 deletions

diff --git a/core/collections.nom b/core/collections.nom
index 428ed4d..f74b24d 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V2.4.4.3
+#!/usr/bin/env nomsu -V2.5.4.3
 #
     This file contains code that supports manipulating and using collections like lists
     and dictionaries.
@@ -9,10 +9,12 @@ use "core/operators.nom"
 
 # List/dict functions:
 # Indexing
-test: assume ((2 nd to last in [1, 2, 3, 4, 5]) is 4)
+test:
+    assume ((2 nd to last in [1, 2, 3, 4, 5]) is 4)
+
 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
+    %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))")
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -21,24 +23,34 @@ parse [last in %list] as (1 st to last in %list)
 parse [first in %list] as %list.1
 
 # Membership testing
-test: assume (3 is in [1, 2, 3, 4, 5])
+test:
+    assume (3 is in [1, 2, 3, 4, 5])
+
 action [%item is in %list, %list contains %item, %list has %item]:
-    for %key = %value in %list: if (%key is %item): return (yes)
+    for %key = %value in %list:
+        if (%key is %item): return (yes)
+    
     return (no)
 
-test: assume (99 isn't in [1, 2, 3])
+test:
+    assume (99 isn't in [1, 2, 3])
+
 action [..]
     %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)
+    for %key = %value in %list:
+        if (%key is %item): return (no)
+    
     return (yes)
 
-test: assume ({x: no} has key "x")
+test:
+    assume ({x:no} has key "x")
+
 parse [%list has key %index, %list has index %index] as (%list.%index != (nil))
 test:
-    assume ({x: no} doesn't have key "y")
-    assume (not ({x: no} doesn't have key "x"))
+    assume ({x:no} doesn't have key "y")
+    assume (not ({x:no} doesn't have key "x"))
 
 parse [..]
     %list doesn't have key %index, %list does not have key %index
@@ -58,12 +70,12 @@ test:
     assume ((first in %list) is 2)
 
 compile [..]
-    append %item to %list, add %item to %list, to %list add %item
-    to %list append %item
+    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 [add %item to %list at index %i] to (..)
-    Lua "table.insert(\(%list as lua expr), \(%i as lua expr), \(%item as lua expr))"
+    Lua ".."
+        table.insert(\(%list as lua expr), \(%i as lua expr), \(%item as lua expr))
 
 compile [pop from %list, remove last from %list] to (..)
     Lua value "table.remove(\(%list as lua expr))"
@@ -74,11 +86,15 @@ compile [remove index %index from %list] to (..)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 # List Comprehension
-test: assume (((% * %) for % in [1, 2, 3]) == [1, 4, 9])
+test:
+    assume (((% * %) for % in [1, 2, 3]) == [1, 4, 9])
+
 parse [%expression for %item in %iterable] as (..)
     result of:
         %comprehension = []
-        for %item in %iterable: add %expression to %comprehension
+        for %item in %iterable:
+            add %expression to %comprehension
+        
         return %comprehension
 
 parse [..]
@@ -87,37 +103,49 @@ parse [..]
 ..as (..)
     result of:
         %comprehension = []
-        for %index in %start to %stop via %step: add %expression to %comprehension
+        for %index in %start to %stop via %step:
+            add %expression to %comprehension
+        
         return %comprehension
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-test: assume (((% * %) for % in 1 to 3) == [1, 4, 9])
+test:
+    assume (((% * %) for % in 1 to 3) == [1, 4, 9])
+
 parse [%expression for %var in %start to %stop] as (..)
     %expression for %var in %start to %stop via 1
 
-test: assume (("\%k,\%v" for %k = %v in {x: 1}) == ["x,1"])
+test:
+    assume (("\%k,\%v" for %k = %v in {x:1}) == ["x,1"])
+
 parse [..]
     %expression for %key = %value in %iterable
     %expression for %key %value in %iterable
 ..as (..)
     result of:
         %comprehension = []
-        for %key = %value in %iterable: add %expression to %comprehension
+        for %key = %value in %iterable:
+            add %expression to %comprehension
+        
         return %comprehension
 
 
 # Dict comprehensions
-test: assume (((% * %) = % for % in [1, 2, 3]) == {1: 1, 4: 2, 9: 3})
-parse [%key = %value for %item in %iterable, %key %value for %item in %iterable]
-..as (..)
+test:
+    assume (((% * %) = % for % in [1, 2, 3]) == {1:1, 4:2, 9:3})
+
+parse [%key = %value for %item in %iterable, %key %value for %item in %iterable] as
+..(..)
     result of:
         %comprehension = {}
-        for %item in %iterable: %comprehension.%key = %value
+        for %item in %iterable:
+            %comprehension.%key = %value
+        
         return %comprehension
 
 test:
-    assume ((%k = (%v * %v) for %k = %v in {x: 1, y: 2, z: 3}) == {x: 1, y: 4, z: 9})
+    assume ((%k = (%v * %v) for %k = %v in {x:1, y:2, z:3}) == {x:1, y:4, z:9})
 
 parse [..]
     %key = %value for %src_key = %src_value in %iterable
@@ -125,7 +153,9 @@ parse [..]
 ..as (..)
     result of:
         %comprehension = {}
-        for %src_key = %src_value in %iterable: %comprehension.%key = %value
+        for %src_key = %src_value in %iterable:
+            %comprehension.%key = %value
+        
         return %comprehension
 
 parse [..]
@@ -134,40 +164,56 @@ parse [..]
 ..as (..)
     result of:
         %comprehension = {}
-        for %item in %start to %stop via %step: %comprehension.%key = %value
+        for %item in %start to %stop via %step:
+            %comprehension.%key = %value
+        
         return %comprehension
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-test: assume (((% * %) = % for % in 1 to 3) == {1: 1, 4: 2, 9: 3})
+test:
+    assume (((% * %) = % for % in 1 to 3) == {1:1, 4:2, 9:3})
+
 parse [..]
     %key = %value for %item in %start to %stop
     %key %value for %item in %start to %stop
 ..as (%key = %value for %item in %start to %stop via 1)
 
-test: assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4])
+test:
+    assume (([[1, 2], [3, 4]] flattened) == [1, 2, 3, 4])
+
 action [%lists flattened]:
     %flat = []
-    for %list in %lists: for %item in %list: add %item to %flat
+    for %list in %lists:
+        for %item in %list: add %item to %flat
+    
     return %flat
 
-test: assume ((entries in {x: 1}) == [{key: "x", value: 1}])
-parse [entries in %dict] as ({key: %k, value: %v} for %k = %v in %dict)
-test: assume ((keys in {x: 1}) == ["x"])
+test:
+    assume ((entries in {x:1}) == [{key:"x", value:1}])
+
+parse [entries in %dict] as ({key:%k, value:%v} for %k = %v in %dict)
+test:
+    assume ((keys in {x:1}) == ["x"])
+
 parse [keys in %dict, keys of %dict] as (%k for %k = %v in %dict)
-test: assume ((values in {x: 1}) == [1])
+test:
+    assume ((values in {x:1}) == [1])
+
 parse [values in %dict, values of %dict] as (%v for %k = %v in %dict)
 
 # Metatable stuff
 test:
     %t = {}
-    set %t 's metatable to {__tostring: [%] -> "XXX"}
+    set %t 's metatable to {__tostring:[%] -> "XXX"}
     assume ("\%t" == "XXX")
 
 compile [set %dict 's metatable to %metatable] to (..)
     Lua "setmetatable(\(%dict as lua expr), \(%metatable as lua expr));"
 
-test: assume (({} with fallback % -> (% + 1)).10 == 11)
+test:
+    assume (({} with fallback % -> (% + 1)).10 == 11)
+
 compile [%dict with fallback %key -> %value] to (..)
     Lua value ".."
         setmetatable(\(%dict as lua expr), {__index=function(self, \(%key as lua expr))
@@ -184,7 +230,7 @@ test:
     assume (%x == [1, 2, 3])
     sort %x by % = (- %)
     assume (%x == [3, 2, 1])
-    %keys = {1: 999, 2: 0, 3: 50}
+    %keys = {1:999, 2:0, 3:50}
     sort %x by % = %keys.%
     assume (%x == [2, 3, 1])
 
@@ -196,7 +242,9 @@ parse [sort %items by %item = %key_expr, sort %items by %item -> %key_expr] as (
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-test: assume ((sorted [3, 1, 2]) == [1, 2, 3])
+test:
+    assume ((sorted [3, 1, 2]) == [1, 2, 3])
+
 action [%items sorted, sorted %items]:
     %copy = (% for % in %items)
     sort %copy
@@ -208,9 +256,15 @@ parse [%items sorted by %item = %key, %items sorted by %item -> %key] as (..)
         sort %copy by %item = %key
         return %copy
 
-test: assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
+test:
+    assume ((unique [1, 2, 1, 3, 2, 3]) == [1, 2, 3])
+
 action [unique %items]:
     %unique = []
     %seen = {}
-    for % in %items: unless %seen.% (: add % to %unique; %seen.% = (yes))
+    for % in %items:
+        unless %seen.%:
+            add % to %unique
+            %seen.% = (yes)
+    
     return %unique
\ No newline at end of file