Upgrading to version 2.3 (main change: "=" instead of "<-" for

assignment)

1 files changed, 45 insertions, 49 deletions

diff --git a/core/collections.nom b/core/collections.nom
index d99ae49..45ca74c 100644
--- a/core/collections.nom
+++ b/core/collections.nom
@@ -1,4 +1,4 @@
-#!/usr/bin/env nomsu -V2.2.4.3
+#!/usr/bin/env nomsu -V2.3.4.3
 #
     This file contains code that supports manipulating and using collections like lists
     and dictionaries.
@@ -34,22 +34,22 @@ action [..]
     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
     %list doesn't have index %index, %list does not have index %index
-..as (%list.%index = (nil))
+..as (%list.%index == (nil))
 
 compile [number of keys in %list] to (..)
     Lua value "utils.size(\(%list as lua expr))"
 
 test:
-    %list <- [1, 2, 3, 4, 5]
+    %list = [1, 2, 3, 4, 5]
     append 6 to %list
     assume ((last in %list) is 6)
     pop from %list
@@ -74,10 +74,10 @@ 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 <- []
+        %comprehension = []
         for %item in %iterable: add %expression to %comprehension
         return %comprehension
 
@@ -86,47 +86,46 @@ parse [..]
     %expression for %index in %start to %stop by %step
 ..as (..)
     result of:
-        %comprehension <- []
+        %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 <- []
+        %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})
+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
+        %comprehension = {}
+        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
     %key %value for %src_key %src_value in %iterable
 ..as (..)
     result of:
-        %comprehension <- {}
-        for %src_key = %src_value in %iterable: %comprehension.%key <- %value
+        %comprehension = {}
+        for %src_key = %src_value in %iterable: %comprehension.%key = %value
         return %comprehension
 
 parse [..]
@@ -134,41 +133,41 @@ parse [..]
     %key %value for %item in %start to %stop via %step
 ..as (..)
     result of:
-        %comprehension <- {}
-        for %item in %start to %stop via %step: %comprehension.%key <- %value
+        %comprehension = {}
+        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 <- []
+    %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"}
-    assume ("\%t" = "XXX")
+    %t = {}
+    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))
@@ -180,41 +179,38 @@ compile [%dict with fallback %key -> %value] to (..)
 
 # Sorting
 test:
-    %x <- [3, 1, 2]
+    %x = [3, 1, 2]
     sort %x
-    assume (%x = [1, 2, 3])
+    assume (%x == [1, 2, 3])
     sort %x by % = (- %)
-    assume (%x = [3, 2, 1])
-    %keys <- {1: 999, 2: 0, 3: 50}
+    assume (%x == [3, 2, 1])
+    %keys = {1: 999, 2: 0, 3: 50}
     sort %x by % = %keys.%
-    assume (%x = [2, 3, 1])
+    assume (%x == [2, 3, 1])
 
 compile [sort %items] to (Lua "table.sort(\(%items as lua expr));")
 parse [sort %items by %item = %key_expr, sort %items by %item -> %key_expr] as (..)
     do:
-        %keys <- ({} with fallback %item -> %key_expr)
+        %keys = ({} with fallback %item -> %key_expr)
         lua> "table.sort(\%items, function(x,y) return \%keys[x] < \%keys[y] end)"
 
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-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)
+    %copy = (% for % in %items)
     sort %copy
     return %copy
 
 parse [%items sorted by %item = %key, %items sorted by %item -> %key] as (..)
     result of:
-        %copy <- (% for % in %items)
+        %copy = (% for % in %items)
         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)
-    return %unique
+    %unique = []
+    %seen = {}
+    for % in %items: unless %seen.% (: add % to %unique; %seen.% = (yes))
+    return %unique
\ No newline at end of file